widgets module

widgets module.

contains QtWidgets-based classes

__all__ = ['app', 'Application', 'AbstractSlider', 'AbstractSliderMixin', 'AbstractButton', 'AbstractButtonMixin', 'AbstractSpinBox', 'AbstractSpinBoxMixin', 'AbstractScrollArea', 'AbstractScrollAreaMixin', 'AbstractItemView', 'AbstractItemViewMixin', 'MdiSubWindow', 'MdiArea', 'ScrollBar', 'ScrollArea', 'Widget', 'WidgetMixin', 'RubberBand', 'GraphicsTransform', 'GraphicsTransformMixin', 'GraphicsRotation', 'GraphicsScale', 'GraphicsItem', 'GraphicsItemMixin', 'GraphicsItemGroup', 'AbstractGraphicsShapeItem', 'AbstractGraphicsShapeItemMixin', 'GraphicsPixmapItem', 'GraphicsObject', 'GraphicsObjectMixin', 'GraphicsTextItem', 'GraphicsLayoutItem', 'GraphicsLayoutItemMixin', 'GraphicsLayout', 'GraphicsLayoutMixin', 'GraphicsGridLayout', 'GraphicsAnchorLayout', 'GraphicsLinearLayout', 'GraphicsWidget', 'GraphicsWidgetMixin', 'GraphicsProxyWidget', 'GraphicsLineItem', 'GraphicsRectItem', 'GraphicsSimpleTextItem', 'GraphicsPolygonItem', 'GraphicsEllipseItem', 'GraphicsPathItem', 'GraphicsWidget', 'GraphicsEffect', 'GraphicsEffectMixin', 'GraphicsBlurEffect', 'GraphicsDropShadowEffect', 'GraphicsColorizeEffect', 'GraphicsOpacityEffect', 'GraphicsScene', 'GraphicsView', 'GraphicsViewMixin', 'Style', 'StyleMixin', 'CommonStyle', 'CommonStyleMixin', 'ProxyStyle', 'StyleOption', 'StyleOptionMixin', 'StyleOptionComplex', 'StyleOptionComplexMixin', 'SpacerItem', 'SizePolicy', 'StylePainter', 'StyleFactory', 'Dialog', 'DialogMixin', 'MessageBox', 'ErrorMessage', 'FileIconProvider', 'FileSystemModel', 'LayoutItem', 'LayoutItemMixin', 'WidgetItem', 'Layout', 'LayoutMixin', 'FormLayout', 'BoxLayout', 'StackedLayout', 'GridLayout', 'ToolBox', 'Slider', 'Dial', 'StyleOptionButton', 'StyleOptionDockWidget', 'StyleOptionFocusRect', 'StyleOptionGraphicsItem', 'StyleOptionHeader', 'StyleOptionMenuItem', 'StyleOptionProgressBar', 'StyleOptionRubberBand', 'StyleOptionTab', 'StyleOptionTabBarBase', 'StyleOptionTabWidgetFrame', 'StyleOptionToolBar', 'StyleOptionToolBox', 'StyleOptionViewItem', 'StyleOptionComboBox', 'StyleOptionGroupBox', 'StyleOptionSizeGrip', 'StyleOptionSlider', 'StyleOptionSpinBox', 'StyleOptionTitleBar', 'StyleOptionToolButton', 'StyleOptionFrame', 'Frame', 'FrameMixin', 'FocusFrame', 'ListWidgetItem', 'TreeWidgetItem', 'TreeWidgetItemIterator', 'Action', 'ActionMixin', 'ActionGroup', 'WidgetAction', 'ToolButton', 'ToolTip', 'Menu', 'MenuBar', 'StatusBar', 'TabWidget', 'TabBar', 'ToolBar', 'HeaderView', 'DockWidget', 'Label', 'PushButton', 'PushButtonMixin', 'CommandLinkButton', 'RadioButton', 'ComboBox', 'ComboBoxMixin', 'FontComboBox', 'SpinBox', 'DoubleSpinBox', 'CheckBox', 'LineEdit', 'KeySequenceEdit', 'TextEdit', 'TextEditMixin', 'DateEdit', 'TimeEdit', 'DateTimeEdit', 'DateTimeEditMixin', 'CalendarWidget', 'PlainTextEdit', 'PlainTextEditMixin', 'TextBrowser', 'Completer', 'ProgressBar', 'LCDNumber', 'ColumnView', 'ListView', 'ListViewMixin', 'ListWidget', 'TreeView', 'TreeViewMixin', 'TreeWidget', 'TableWidgetSelectionRange', 'ScrollerProperties', 'Scroller', 'TableView', 'TableViewMixin', 'TableWidgetItem', 'TableWidget', 'SplashScreen', 'ProgressDialog', 'FontDialog', 'FileDialog', 'ColorDialog', 'InputDialog', 'DialogButtonBox', 'ButtonGroup', 'GroupBox', 'SplitterHandle', 'Splitter', 'Wizard', 'WizardPage', 'StackedWidget', 'MainWindow', 'Shortcut', 'WhatsThis', 'AbstractItemDelegate', 'AbstractItemDelegateMixin', 'ItemDelegate', 'StyledItemDelegate', 'SystemTrayIcon', 'UndoView', 'DataWidgetMapper', 'SizeGrip', 'KeyEventTransition', 'MouseEventTransition', 'GraphicsSceneHoverEvent', 'GraphicsSceneMouseEvent', 'GraphicsSceneWheelEvent', 'GraphicsSceneContextMenuEvent', 'GraphicsSceneDragDropEvent', 'GraphicsSceneHelpEvent', 'GraphicsSceneMoveEvent', 'GraphicsSceneResizeEvent', 'GraphicsSceneEvent', 'GestureEvent', 'PlainTextDocumentLayout', 'Gesture', 'GestureMixin', 'TapGesture', 'TapAndHoldGesture', 'PanGesture', 'PinchGesture', 'SwipeGesture', 'ItemEditorFactory', 'ItemEditorCreatorBase'] module-attribute

AbstractButton

Bases: AbstractButtonMixin, QtWidgets.QAbstractButton

Source code in prettyqt\widgets\abstractbutton.py

class AbstractButton(AbstractButtonMixin, QtWidgets.QAbstractButton):
    pass

AbstractButtonMixin

Bases: widgets.WidgetMixin

Source code in prettyqt\widgets\abstractbutton.py

class AbstractButtonMixin(widgets.WidgetMixin):
    def __bool__(self):
        return self.isChecked()

    def set_icon(self, icon: datatypes.IconType):
        """Set the icon for the button.

        Args:
            icon: icon to use
        """
        icon = iconprovider.get_icon(icon)
        self.setIcon(icon)

    def get_icon(self) -> gui.Icon | None:
        icon = self.icon()
        return None if icon.isNull() else gui.Icon(icon)

    def set_style_icon(self, icon: widgets.style.StandardPixmapStr, size: int = 15):
        """Set theme icon for the button.

        Args:
            icon: icon to use
            size: icon size
        """
        if icon not in widgets.style.STANDARD_PIXMAP:
            raise InvalidParamError(icon, widgets.style.STANDARD_PIXMAP)
        qicon = self.style().standardIcon(widgets.style.STANDARD_PIXMAP[icon], None, self)
        self.set_icon(qicon)
        self.setIconSize(core.Size(size, size))

    def set_shortcut(self, shortcut: None | QtGui.QKeySequence | str):
        if shortcut is None:
            shortcut = ""
        if isinstance(shortcut, str):
            shortcut = gui.KeySequence(
                shortcut, gui.KeySequence.SequenceFormat.PortableText
            )
        self.setShortcut(shortcut)

    def get_shortcut(self) -> gui.KeySequence:
        return gui.KeySequence(
            self.shortcut().toString(), gui.KeySequence.SequenceFormat.PortableText
        )

    def set_text(self, text: str):
        self.setText(text)

    def set_icon_size(self, size: int | datatypes.SizeType):
        """Set size of the icon."""
        if isinstance(size, int):
            size = core.Size(size, size)
        elif isinstance(size, tuple):
            size = core.Size(*size)
        self.setIconSize(size)

    def get_icon_size(self) -> core.Size:
        return core.Size(self.iconSize())

    def get_value(self) -> bool:
        return self.isChecked()

    def set_value(self, value: bool):
        self.setChecked(value)

    @property
    def is_on(self) -> bool:
        return self.isChecked()

    @is_on.setter
    def is_on(self, state: bool):
        self.setChecked(state)

is_on: bool writable property

__bool__()

Source code in prettyqt\widgets\abstractbutton.py

def __bool__(self):
    return self.isChecked()

get_icon() -> gui.Icon | None

Source code in prettyqt\widgets\abstractbutton.py

def get_icon(self) -> gui.Icon | None:
    icon = self.icon()
    return None if icon.isNull() else gui.Icon(icon)

get_icon_size() -> core.Size

Source code in prettyqt\widgets\abstractbutton.py

def get_icon_size(self) -> core.Size:
    return core.Size(self.iconSize())

get_shortcut() -> gui.KeySequence

Source code in prettyqt\widgets\abstractbutton.py

def get_shortcut(self) -> gui.KeySequence:
    return gui.KeySequence(
        self.shortcut().toString(), gui.KeySequence.SequenceFormat.PortableText
    )

get_value() -> bool

Source code in prettyqt\widgets\abstractbutton.py

def get_value(self) -> bool:
    return self.isChecked()

set_icon(icon: datatypes.IconType)

Set the icon for the button.

Parameters:

Name	Type	Description	Default
icon	datatypes.IconType	icon to use	required

Source code in prettyqt\widgets\abstractbutton.py

def set_icon(self, icon: datatypes.IconType):
    """Set the icon for the button.

    Args:
        icon: icon to use
    """
    icon = iconprovider.get_icon(icon)
    self.setIcon(icon)

set_icon_size(size: int | datatypes.SizeType)

Set size of the icon.

Source code in prettyqt\widgets\abstractbutton.py

def set_icon_size(self, size: int | datatypes.SizeType):
    """Set size of the icon."""
    if isinstance(size, int):
        size = core.Size(size, size)
    elif isinstance(size, tuple):
        size = core.Size(*size)
    self.setIconSize(size)

set_shortcut(shortcut: None | QtGui.QKeySequence | str)

Source code in prettyqt\widgets\abstractbutton.py

def set_shortcut(self, shortcut: None | QtGui.QKeySequence | str):
    if shortcut is None:
        shortcut = ""
    if isinstance(shortcut, str):
        shortcut = gui.KeySequence(
            shortcut, gui.KeySequence.SequenceFormat.PortableText
        )
    self.setShortcut(shortcut)

set_style_icon(icon: widgets.style.StandardPixmapStr, size: int = 15)

Set theme icon for the button.

Parameters:

Name	Type	Description	Default
icon	widgets.style.StandardPixmapStr	icon to use	required
size	int	icon size	15

Source code in prettyqt\widgets\abstractbutton.py

def set_style_icon(self, icon: widgets.style.StandardPixmapStr, size: int = 15):
    """Set theme icon for the button.

    Args:
        icon: icon to use
        size: icon size
    """
    if icon not in widgets.style.STANDARD_PIXMAP:
        raise InvalidParamError(icon, widgets.style.STANDARD_PIXMAP)
    qicon = self.style().standardIcon(widgets.style.STANDARD_PIXMAP[icon], None, self)
    self.set_icon(qicon)
    self.setIconSize(core.Size(size, size))

set_text(text: str)

Source code in prettyqt\widgets\abstractbutton.py

def set_text(self, text: str):
    self.setText(text)

set_value(value: bool)

Source code in prettyqt\widgets\abstractbutton.py

def set_value(self, value: bool):
    self.setChecked(value)

AbstractGraphicsShapeItem

Bases: AbstractGraphicsShapeItemMixin, QtWidgets.QAbstractGraphicsShapeItem

Source code in prettyqt\widgets\abstractgraphicsshapeitem.py

class AbstractGraphicsShapeItem(
    AbstractGraphicsShapeItemMixin, QtWidgets.QAbstractGraphicsShapeItem
):
    pass

AbstractGraphicsShapeItemMixin

Bases: widgets.GraphicsItemMixin

Source code in prettyqt\widgets\abstractgraphicsshapeitem.py

class AbstractGraphicsShapeItemMixin(widgets.GraphicsItemMixin):
    pass

AbstractItemDelegate

Bases: AbstractItemDelegateMixin, QtWidgets.QAbstractItemDelegate

Source code in prettyqt\widgets\abstractitemdelegate.py

class AbstractItemDelegate(AbstractItemDelegateMixin, QtWidgets.QAbstractItemDelegate):
    pass

AbstractItemDelegateMixin

Bases: core.ObjectMixin

Source code in prettyqt\widgets\abstractitemdelegate.py

class AbstractItemDelegateMixin(core.ObjectMixin):
    pass

AbstractItemView

Bases: AbstractItemViewMixin, QtWidgets.QAbstractItemView

Source code in prettyqt\widgets\abstractitemview.py

class AbstractItemView(AbstractItemViewMixin, QtWidgets.QAbstractItemView):
    pass

AbstractItemViewMixin

Bases: widgets.AbstractScrollAreaMixin

Source code in prettyqt\widgets\abstractitemview.py

class AbstractItemViewMixin(widgets.AbstractScrollAreaMixin):
    model_changed = core.Signal(QtCore.QAbstractItemModel)

    def __len__(self) -> int:
        return model.rowCount() if (model := self.model()) is not None else 0

    def selectAll(self):
        """Override, we dont want to selectAll for too many items bc of performance."""
        if self.model() is None:
            return
        if self.model().rowCount() * self.model().columnCount() > 1_000_000:
            logger.warning("Too many cells to select.")
            return
        super().selectAll()

    def set_model(self, model: QtCore.QAbstractItemModel | None):
        """Delete old selection model explicitely, seems to help with memory usage."""
        old_model = self.model()
        old_sel_model = self.selectionModel()
        if old_model is not None or model is not None:
            self.setModel(model)  # type: ignore
            self.model_changed.emit(model)
        # if old_model:
        #     old_model.deleteLater()
        #     del old_model
        if old_sel_model:
            old_sel_model.deleteLater()
            del old_sel_model

    def set_delegate(
        self,
        delegate: QtWidgets.QAbstractItemDelegate,
        column: int | None = None,
        row: int | None = None,
        persistent: bool = False,
    ):
        if column is not None:
            self.setItemDelegateForColumn(column, delegate)
            if persistent:
                model = self.model()
                for i in range(model.rowCount()):
                    index = model.index(i, column)
                    self.openPersistentEditor(index)
        elif row is not None:
            self.setItemDelegateForRow(row, delegate)
            if persistent:
                model = self.model()
                for i in range(model.columnCount()):
                    self.openPersistentEditor(model.index(row, i))
        else:
            self.setItemDelegate(delegate)

    def toggle_select_all(self):
        """Select all items from list (deselect when all selected)."""
        if self.selectionModel() is None:
            return
        if self.selectionModel().hasSelection():
            self.clearSelection()
        else:
            self.selectAll()

    def set_table_color(self, color: str):
        with self.edit_stylesheet() as ss:
            ss.QHeaderView.section.backgroundColor.setValue(color)

    def current_index(self) -> QtCore.QModelIndex | None:
        if (model := self.selectionModel()) is not None:
            return model.currentIndex()

    def current_data(self):
        if (model := self.selectionModel()) is not None:
            idx = model.currentIndex()
            return idx.data(constants.USER_ROLE)  # type: ignore

    def current_row(self) -> int | None:
        if (model := self.selectionModel()) is not None:
            return model.currentIndex().row()

    def current_column(self) -> int | None:
        if (model := self.selectionModel()) is not None:
            return model.currentIndex().column()

    def selected_indexes(self) -> list[QtCore.QModelIndex]:
        """Return list of selected indexes in first row."""
        indexes = (x for x in self.selectedIndexes() if x.column() == 0)  # type: ignore
        return sorted(indexes, key=lambda x: x.row())  # type: ignore

    def selected_names(self) -> Generator[Any, None, None]:
        """Return generator yielding item names."""
        return (x.data(constants.NAME_ROLE) for x in self.selected_indexes())

    def selected_rows(self) -> Generator[int, None, None]:
        """Return generator yielding row nums."""
        return (x.row() for x in self.selected_indexes())

    def selected_data(self) -> Generator[Any, None, None]:
        """Return generator yielding selected userData."""
        return (
            x.data(constants.USER_ROLE) for x in self.selected_indexes()  # type: ignore
        )

    def setup_dragdrop_move(self):
        self.setDragEnabled(True)
        self.setAcceptDrops(True)
        self.setDragDropMode(self.DragDropMode.DragDrop)
        self.setDefaultDropAction(constants.MOVE_ACTION)
        self.setDropIndicatorShown(True)

    def set_edit_triggers(self, *triggers: EditTriggerStr | None):
        items = ["none" if t is None else t for t in triggers]
        for item in items:
            if item not in EDIT_TRIGGERS:
                raise InvalidParamError(item, EDIT_TRIGGERS)
        flags = helpers.merge_flags(items, EDIT_TRIGGERS)
        self.setEditTriggers(flags)

    def get_edit_triggers(self) -> list[EditTriggerStr]:
        return EDIT_TRIGGERS.get_list(self.editTriggers())

    def set_selection_behaviour(self, behaviour: SelectionBehaviourStr):
        """Set selection behaviour for given item view.

        Args:
            behaviour: selection behaviour to use

        Raises:
            InvalidParamError: behaviour does not exist
        """
        if behaviour not in SELECTION_BEHAVIOUR:
            raise InvalidParamError(behaviour, SELECTION_BEHAVIOUR)
        self.setSelectionBehavior(SELECTION_BEHAVIOUR[behaviour])

    def get_selection_behaviour(self) -> SelectionBehaviourStr:
        """Return current selection behaviour.

        Returns:
            selection behaviour
        """
        return SELECTION_BEHAVIOUR.inverse[self.selectionBehavior()]

    def set_drag_drop_mode(self, mode: DragDropModeStr):
        """Set drag-drop mode for given item view.

        Args:
            mode: drag-drop mode to use

        Raises:
            InvalidParamError: mode does not exist
        """
        if mode not in DRAG_DROP_MODE:
            raise InvalidParamError(mode, DRAG_DROP_MODE)
        self.setDragDropMode(DRAG_DROP_MODE[mode])

    def get_drag_drop_mode(self) -> DragDropModeStr:
        """Return current drag-drop mode.

        Returns:
            drag-drop mode
        """
        return DRAG_DROP_MODE.inverse[self.dragDropMode()]

    def set_selection_mode(self, mode: SelectionModeStr | None):
        """Set selection mode for given item view.

        Args:
            mode: selection mode to use

        Raises:
            InvalidParamError: mode does not exist
        """
        if mode is None:
            mode = "none"
        if mode not in SELECTION_MODE:
            raise InvalidParamError(mode, SELECTION_MODE)
        self.setSelectionMode(SELECTION_MODE[mode])

    def get_selection_mode(self) -> SelectionModeStr:
        """Return current selection mode.

        Returns:
            selection mode
        """
        return SELECTION_MODE.inverse[self.selectionMode()]

    def set_scroll_mode(self, mode: ScrollModeStr):
        """Set the scroll mode for both directions.

        Args:
            mode: mode to set

        Raises:
            InvalidParamError: invalid scroll mode
        """
        if mode not in SCROLL_MODE:
            raise InvalidParamError(mode, SCROLL_MODE)
        self.setHorizontalScrollMode(SCROLL_MODE[mode])
        self.setVerticalScrollMode(SCROLL_MODE[mode])

    def set_horizontal_scroll_mode(self, mode: ScrollModeStr):
        """Set the horizontal scroll mode.

        Args:
            mode: mode to set

        Raises:
            InvalidParamError: invalid scroll mode
        """
        if mode not in SCROLL_MODE:
            raise InvalidParamError(mode, SCROLL_MODE)
        self.setHorizontalScrollMode(SCROLL_MODE[mode])

    def get_horizontal_scroll_mode(self) -> ScrollModeStr:
        """Return current horizontal scroll mode.

        Returns:
            horizontal scroll mode
        """
        return SCROLL_MODE.inverse[self.horizontalScrollMode()]

    def set_vertical_scroll_mode(self, mode: ScrollModeStr):
        """Set the vertical scroll mode.

        Args:
            mode: mode to set

        Raises:
            InvalidParamError: invalid scroll mode
        """
        if mode not in SCROLL_MODE:
            raise InvalidParamError(mode, SCROLL_MODE)
        self.setVerticalScrollMode(SCROLL_MODE[mode])

    def get_vertical_scroll_mode(self) -> ScrollModeStr:
        """Return current vertical scroll mode.

        Returns:
            vertical scroll mode
        """
        return SCROLL_MODE.inverse[self.verticalScrollMode()]

    def num_selected(self) -> int:
        """Return amount of selected rows.

        Returns:
            amount of selected rows
        """
        if (model := self.selectionModel()) is not None:
            return len(model.selectedRows())
        return 0

    def jump_to_column(self, col_num: int):
        """Make sure column at given index is visible.

        scrolls to column at given index

        Args:
            col_num: column to scroll to
        """
        if (model := self.model()) is not None:
            idx = model.index(0, col_num)
            self.scrollTo(idx)

    def scroll_to_top(self):
        """Override to use abstractitemview-way of scrolling to top."""
        self.scrollToTop()

    def scroll_to_bottom(self):
        """Override to use abstractitemview-way of scrolling to bottom."""
        self.scrollToBottom()

    def select_last_row(self):
        idx = self.model().createIndex(self.model().rowCount() - 1, 0)
        self.setCurrentIndex(idx)

    def scroll_to(self, index, mode: ScrollHintStr = "ensure_visible"):
        if mode not in SCROLL_HINT:
            raise InvalidParamError(mode, SCROLL_HINT)
        self.scrollTo(index, SCROLL_HINT[mode])

    def highlight_when_inactive(self):
        """Highlight items when widget does not have focus."""
        p = gui.Palette()
        p.highlight_inactive()
        self.setPalette(p)

    def set_icon_size(self, size: int | datatypes.SizeType):
        if isinstance(size, tuple):
            size = QtCore.QSize(*size)
        elif isinstance(size, int):
            size = QtCore.QSize(size, size)
        self.setIconSize(size)

model_changed = core.Signal(QtCore.QAbstractItemModel) class-attribute

__len__() -> int

Source code in prettyqt\widgets\abstractitemview.py

def __len__(self) -> int:
    return model.rowCount() if (model := self.model()) is not None else 0

current_column() -> int | None

Source code in prettyqt\widgets\abstractitemview.py

def current_column(self) -> int | None:
    if (model := self.selectionModel()) is not None:
        return model.currentIndex().column()

current_data()

Source code in prettyqt\widgets\abstractitemview.py

def current_data(self):
    if (model := self.selectionModel()) is not None:
        idx = model.currentIndex()
        return idx.data(constants.USER_ROLE)  # type: ignore

current_index() -> QtCore.QModelIndex | None

Source code in prettyqt\widgets\abstractitemview.py

def current_index(self) -> QtCore.QModelIndex | None:
    if (model := self.selectionModel()) is not None:
        return model.currentIndex()

current_row() -> int | None

Source code in prettyqt\widgets\abstractitemview.py

def current_row(self) -> int | None:
    if (model := self.selectionModel()) is not None:
        return model.currentIndex().row()

get_drag_drop_mode() -> DragDropModeStr

Return current drag-drop mode.

Returns:

Type	Description
DragDropModeStr	drag-drop mode

Source code in prettyqt\widgets\abstractitemview.py

def get_drag_drop_mode(self) -> DragDropModeStr:
    """Return current drag-drop mode.

    Returns:
        drag-drop mode
    """
    return DRAG_DROP_MODE.inverse[self.dragDropMode()]

get_edit_triggers() -> list[EditTriggerStr]

Source code in prettyqt\widgets\abstractitemview.py

def get_edit_triggers(self) -> list[EditTriggerStr]:
    return EDIT_TRIGGERS.get_list(self.editTriggers())

get_horizontal_scroll_mode() -> ScrollModeStr

Return current horizontal scroll mode.

Returns:

Type	Description
ScrollModeStr	horizontal scroll mode

Source code in prettyqt\widgets\abstractitemview.py

def get_horizontal_scroll_mode(self) -> ScrollModeStr:
    """Return current horizontal scroll mode.

    Returns:
        horizontal scroll mode
    """
    return SCROLL_MODE.inverse[self.horizontalScrollMode()]

get_selection_behaviour() -> SelectionBehaviourStr

Return current selection behaviour.

Returns:

Type	Description
SelectionBehaviourStr	selection behaviour

Source code in prettyqt\widgets\abstractitemview.py

def get_selection_behaviour(self) -> SelectionBehaviourStr:
    """Return current selection behaviour.

    Returns:
        selection behaviour
    """
    return SELECTION_BEHAVIOUR.inverse[self.selectionBehavior()]

get_selection_mode() -> SelectionModeStr

Return current selection mode.

Returns:

Type	Description
SelectionModeStr	selection mode

Source code in prettyqt\widgets\abstractitemview.py

def get_selection_mode(self) -> SelectionModeStr:
    """Return current selection mode.

    Returns:
        selection mode
    """
    return SELECTION_MODE.inverse[self.selectionMode()]

get_vertical_scroll_mode() -> ScrollModeStr

Return current vertical scroll mode.

Returns:

Type	Description
ScrollModeStr	vertical scroll mode

Source code in prettyqt\widgets\abstractitemview.py

def get_vertical_scroll_mode(self) -> ScrollModeStr:
    """Return current vertical scroll mode.

    Returns:
        vertical scroll mode
    """
    return SCROLL_MODE.inverse[self.verticalScrollMode()]

highlight_when_inactive()

Highlight items when widget does not have focus.

Source code in prettyqt\widgets\abstractitemview.py

def highlight_when_inactive(self):
    """Highlight items when widget does not have focus."""
    p = gui.Palette()
    p.highlight_inactive()
    self.setPalette(p)

jump_to_column(col_num: int)

Make sure column at given index is visible.

scrolls to column at given index

Parameters:

Name	Type	Description	Default
col_num	int	column to scroll to	required

Source code in prettyqt\widgets\abstractitemview.py

def jump_to_column(self, col_num: int):
    """Make sure column at given index is visible.

    scrolls to column at given index

    Args:
        col_num: column to scroll to
    """
    if (model := self.model()) is not None:
        idx = model.index(0, col_num)
        self.scrollTo(idx)

num_selected() -> int

Return amount of selected rows.

Returns:

Type	Description
int	amount of selected rows

Source code in prettyqt\widgets\abstractitemview.py

def num_selected(self) -> int:
    """Return amount of selected rows.

    Returns:
        amount of selected rows
    """
    if (model := self.selectionModel()) is not None:
        return len(model.selectedRows())
    return 0

scroll_to(index, mode: ScrollHintStr = 'ensure_visible')

Source code in prettyqt\widgets\abstractitemview.py

def scroll_to(self, index, mode: ScrollHintStr = "ensure_visible"):
    if mode not in SCROLL_HINT:
        raise InvalidParamError(mode, SCROLL_HINT)
    self.scrollTo(index, SCROLL_HINT[mode])

scroll_to_bottom()

Override to use abstractitemview-way of scrolling to bottom.

Source code in prettyqt\widgets\abstractitemview.py

def scroll_to_bottom(self):
    """Override to use abstractitemview-way of scrolling to bottom."""
    self.scrollToBottom()

scroll_to_top()

Override to use abstractitemview-way of scrolling to top.

Source code in prettyqt\widgets\abstractitemview.py

def scroll_to_top(self):
    """Override to use abstractitemview-way of scrolling to top."""
    self.scrollToTop()

selectAll()

Override, we dont want to selectAll for too many items bc of performance.

Source code in prettyqt\widgets\abstractitemview.py

def selectAll(self):
    """Override, we dont want to selectAll for too many items bc of performance."""
    if self.model() is None:
        return
    if self.model().rowCount() * self.model().columnCount() > 1_000_000:
        logger.warning("Too many cells to select.")
        return
    super().selectAll()

select_last_row()

Source code in prettyqt\widgets\abstractitemview.py

def select_last_row(self):
    idx = self.model().createIndex(self.model().rowCount() - 1, 0)
    self.setCurrentIndex(idx)

selected_data() -> Generator[Any, None, None]

Return generator yielding selected userData.

Source code in prettyqt\widgets\abstractitemview.py

def selected_data(self) -> Generator[Any, None, None]:
    """Return generator yielding selected userData."""
    return (
        x.data(constants.USER_ROLE) for x in self.selected_indexes()  # type: ignore
    )

selected_indexes() -> list[QtCore.QModelIndex]

Return list of selected indexes in first row.

Source code in prettyqt\widgets\abstractitemview.py

def selected_indexes(self) -> list[QtCore.QModelIndex]:
    """Return list of selected indexes in first row."""
    indexes = (x for x in self.selectedIndexes() if x.column() == 0)  # type: ignore
    return sorted(indexes, key=lambda x: x.row())  # type: ignore

selected_names() -> Generator[Any, None, None]

Return generator yielding item names.

Source code in prettyqt\widgets\abstractitemview.py

def selected_names(self) -> Generator[Any, None, None]:
    """Return generator yielding item names."""
    return (x.data(constants.NAME_ROLE) for x in self.selected_indexes())

selected_rows() -> Generator[int, None, None]

Return generator yielding row nums.

Source code in prettyqt\widgets\abstractitemview.py

def selected_rows(self) -> Generator[int, None, None]:
    """Return generator yielding row nums."""
    return (x.row() for x in self.selected_indexes())

set_delegate(delegate: QtWidgets.QAbstractItemDelegate, column: int | None = None, row: int | None = None, persistent: bool = False)

Source code in prettyqt\widgets\abstractitemview.py

def set_delegate(
    self,
    delegate: QtWidgets.QAbstractItemDelegate,
    column: int | None = None,
    row: int | None = None,
    persistent: bool = False,
):
    if column is not None:
        self.setItemDelegateForColumn(column, delegate)
        if persistent:
            model = self.model()
            for i in range(model.rowCount()):
                index = model.index(i, column)
                self.openPersistentEditor(index)
    elif row is not None:
        self.setItemDelegateForRow(row, delegate)
        if persistent:
            model = self.model()
            for i in range(model.columnCount()):
                self.openPersistentEditor(model.index(row, i))
    else:
        self.setItemDelegate(delegate)

set_drag_drop_mode(mode: DragDropModeStr)

Set drag-drop mode for given item view.

Parameters:

Name	Type	Description	Default
mode	DragDropModeStr	drag-drop mode to use	required

Raises:

Type	Description
InvalidParamError	mode does not exist

Source code in prettyqt\widgets\abstractitemview.py

def set_drag_drop_mode(self, mode: DragDropModeStr):
    """Set drag-drop mode for given item view.

    Args:
        mode: drag-drop mode to use

    Raises:
        InvalidParamError: mode does not exist
    """
    if mode not in DRAG_DROP_MODE:
        raise InvalidParamError(mode, DRAG_DROP_MODE)
    self.setDragDropMode(DRAG_DROP_MODE[mode])

set_edit_triggers(*triggers: EditTriggerStr | None)

Source code in prettyqt\widgets\abstractitemview.py

def set_edit_triggers(self, *triggers: EditTriggerStr | None):
    items = ["none" if t is None else t for t in triggers]
    for item in items:
        if item not in EDIT_TRIGGERS:
            raise InvalidParamError(item, EDIT_TRIGGERS)
    flags = helpers.merge_flags(items, EDIT_TRIGGERS)
    self.setEditTriggers(flags)

set_horizontal_scroll_mode(mode: ScrollModeStr)

Set the horizontal scroll mode.

Parameters:

Name	Type	Description	Default
mode	ScrollModeStr	mode to set	required

Raises:

Type	Description
InvalidParamError	invalid scroll mode

Source code in prettyqt\widgets\abstractitemview.py

def set_horizontal_scroll_mode(self, mode: ScrollModeStr):
    """Set the horizontal scroll mode.

    Args:
        mode: mode to set

    Raises:
        InvalidParamError: invalid scroll mode
    """
    if mode not in SCROLL_MODE:
        raise InvalidParamError(mode, SCROLL_MODE)
    self.setHorizontalScrollMode(SCROLL_MODE[mode])

set_icon_size(size: int | datatypes.SizeType)

Source code in prettyqt\widgets\abstractitemview.py

def set_icon_size(self, size: int | datatypes.SizeType):
    if isinstance(size, tuple):
        size = QtCore.QSize(*size)
    elif isinstance(size, int):
        size = QtCore.QSize(size, size)
    self.setIconSize(size)

set_model(model: QtCore.QAbstractItemModel | None)

Delete old selection model explicitely, seems to help with memory usage.

Source code in prettyqt\widgets\abstractitemview.py

def set_model(self, model: QtCore.QAbstractItemModel | None):
    """Delete old selection model explicitely, seems to help with memory usage."""
    old_model = self.model()
    old_sel_model = self.selectionModel()
    if old_model is not None or model is not None:
        self.setModel(model)  # type: ignore
        self.model_changed.emit(model)
    # if old_model:
    #     old_model.deleteLater()
    #     del old_model
    if old_sel_model:
        old_sel_model.deleteLater()
        del old_sel_model

set_scroll_mode(mode: ScrollModeStr)

Set the scroll mode for both directions.

Parameters:

Name	Type	Description	Default
mode	ScrollModeStr	mode to set	required

Raises:

Type	Description
InvalidParamError	invalid scroll mode

Source code in prettyqt\widgets\abstractitemview.py

def set_scroll_mode(self, mode: ScrollModeStr):
    """Set the scroll mode for both directions.

    Args:
        mode: mode to set

    Raises:
        InvalidParamError: invalid scroll mode
    """
    if mode not in SCROLL_MODE:
        raise InvalidParamError(mode, SCROLL_MODE)
    self.setHorizontalScrollMode(SCROLL_MODE[mode])
    self.setVerticalScrollMode(SCROLL_MODE[mode])

set_selection_behaviour(behaviour: SelectionBehaviourStr)

Set selection behaviour for given item view.

Parameters:

Name	Type	Description	Default
behaviour	SelectionBehaviourStr	selection behaviour to use	required

Raises:

Type	Description
InvalidParamError	behaviour does not exist

Source code in prettyqt\widgets\abstractitemview.py

def set_selection_behaviour(self, behaviour: SelectionBehaviourStr):
    """Set selection behaviour for given item view.

    Args:
        behaviour: selection behaviour to use

    Raises:
        InvalidParamError: behaviour does not exist
    """
    if behaviour not in SELECTION_BEHAVIOUR:
        raise InvalidParamError(behaviour, SELECTION_BEHAVIOUR)
    self.setSelectionBehavior(SELECTION_BEHAVIOUR[behaviour])

set_selection_mode(mode: SelectionModeStr | None)

Set selection mode for given item view.

Parameters:

Name	Type	Description	Default
mode	SelectionModeStr | None	selection mode to use	required

Raises:

Type	Description
InvalidParamError	mode does not exist

Source code in prettyqt\widgets\abstractitemview.py

def set_selection_mode(self, mode: SelectionModeStr | None):
    """Set selection mode for given item view.

    Args:
        mode: selection mode to use

    Raises:
        InvalidParamError: mode does not exist
    """
    if mode is None:
        mode = "none"
    if mode not in SELECTION_MODE:
        raise InvalidParamError(mode, SELECTION_MODE)
    self.setSelectionMode(SELECTION_MODE[mode])

set_table_color(color: str)

Source code in prettyqt\widgets\abstractitemview.py

def set_table_color(self, color: str):
    with self.edit_stylesheet() as ss:
        ss.QHeaderView.section.backgroundColor.setValue(color)

set_vertical_scroll_mode(mode: ScrollModeStr)

Set the vertical scroll mode.

Parameters:

Name	Type	Description	Default
mode	ScrollModeStr	mode to set	required

Raises:

Type	Description
InvalidParamError	invalid scroll mode

Source code in prettyqt\widgets\abstractitemview.py

def set_vertical_scroll_mode(self, mode: ScrollModeStr):
    """Set the vertical scroll mode.

    Args:
        mode: mode to set

    Raises:
        InvalidParamError: invalid scroll mode
    """
    if mode not in SCROLL_MODE:
        raise InvalidParamError(mode, SCROLL_MODE)
    self.setVerticalScrollMode(SCROLL_MODE[mode])

setup_dragdrop_move()

Source code in prettyqt\widgets\abstractitemview.py

def setup_dragdrop_move(self):
    self.setDragEnabled(True)
    self.setAcceptDrops(True)
    self.setDragDropMode(self.DragDropMode.DragDrop)
    self.setDefaultDropAction(constants.MOVE_ACTION)
    self.setDropIndicatorShown(True)

toggle_select_all()

Select all items from list (deselect when all selected).

Source code in prettyqt\widgets\abstractitemview.py

def toggle_select_all(self):
    """Select all items from list (deselect when all selected)."""
    if self.selectionModel() is None:
        return
    if self.selectionModel().hasSelection():
        self.clearSelection()
    else:
        self.selectAll()

AbstractScrollArea

Bases: AbstractScrollAreaMixin, QtWidgets.QAbstractScrollArea

Source code in prettyqt\widgets\abstractscrollarea.py

class AbstractScrollArea(AbstractScrollAreaMixin, QtWidgets.QAbstractScrollArea):
    pass

AbstractScrollAreaMixin

Bases: widgets.FrameMixin

Source code in prettyqt\widgets\abstractscrollarea.py

class AbstractScrollAreaMixin(widgets.FrameMixin):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.setHorizontalScrollBar(widgets.ScrollBar(parent=self))
        self.setVerticalScrollBar(widgets.ScrollBar(parent=self))

    @property
    def h_scrollbar(self):
        return self.horizontalScrollBar()

    @h_scrollbar.setter
    def h_scrollbar(self, scrollbar):
        self.setHorizontalScrollBar(scrollbar)

    @property
    def v_scrollbar(self):
        return self.verticalScrollBar()

    @v_scrollbar.setter
    def v_scrollbar(self, scrollbar):
        self.setVerticalScrollBar(scrollbar)

    def set_size_adjust_policy(self, policy: SizePolicyStr):
        """Set size adjust policy.

        Args:
            policy: size adjust policy to use

        Raises:
            InvalidParamError: invalid size adjust policy
        """
        if policy not in SIZE_POLICY:
            raise InvalidParamError(policy, SIZE_POLICY)
        self.setSizeAdjustPolicy(SIZE_POLICY[policy])

    def get_size_adjust_policy(self) -> SizePolicyStr:
        """Return size adjust policy.

        Returns:
            size adjust policy
        """
        return SIZE_POLICY.inverse[self.sizeAdjustPolicy()]

    def set_scrollbar_policy(self, mode: constants.ScrollBarPolicyStr):
        """Set the policy for both scrollbars.

        Args:
            mode: visibilty to set

        Raises:
            InvalidParamError: invalid scrollbar policy
        """
        if mode not in constants.SCROLLBAR_POLICY:
            raise InvalidParamError(mode, constants.SCROLLBAR_POLICY)
        self.setHorizontalScrollBarPolicy(constants.SCROLLBAR_POLICY[mode])
        self.setVerticalScrollBarPolicy(constants.SCROLLBAR_POLICY[mode])

    def set_horizontal_scrollbar_policy(self, mode: constants.ScrollBarPolicyStr):
        """Set the horizontal scrollbar visibility.

        Args:
            mode: visibilty to set

        Raises:
            InvalidParamError: invalid scrollbar policy
        """
        if mode not in constants.SCROLLBAR_POLICY:
            raise InvalidParamError(mode, constants.SCROLLBAR_POLICY)
        self.setHorizontalScrollBarPolicy(constants.SCROLLBAR_POLICY[mode])

    def get_horizontal_scrollbar_policy(self):
        return constants.SCROLLBAR_POLICY.inverse[self.horizontalScrollBarPolicy()]

    def set_vertical_scrollbar_policy(self, mode: constants.ScrollBarPolicyStr):
        """Set the vertical scrollbar visibility.

        Args:
            mode: visibilty to set

        Raises:
            InvalidParamError: invalid scrollbar policy
        """
        if mode not in constants.SCROLLBAR_POLICY:
            raise InvalidParamError(mode, constants.SCROLLBAR_POLICY)
        self.setVerticalScrollBarPolicy(constants.SCROLLBAR_POLICY[mode])

    def get_vertical_scrollbar_policy(self):
        return constants.SCROLLBAR_POLICY.inverse[self.verticalScrollBarPolicy()]

    def set_scrollbar_width(self, width: int):
        """Set the width for both scrollbars.

        Args:
            width: width in pixels
        """
        self.set_horizontal_scrollbar_width(width)
        self.set_vertical_scrollbar_width(width)

    def set_horizontal_scrollbar_width(self, width: int):
        """Set the horizontal scrollbar width.

        Args:
            width: width in pixels
        """
        with self.h_scrollbar.edit_stylesheet() as ss:
            ss.QScrollBar.horizontal.height.setValue(f"{width}px")

    def set_vertical_scrollbar_width(self, width: int):
        """Set the vertical scrollbar width.

        Args:
            width: width in pixels
        """
        with self.v_scrollbar.edit_stylesheet() as ss:
            ss.QScrollBar.horizontal.height.setValue(f"{width}px")

    def scroll_to_top(self):
        """Scroll to the top of the scroll area."""
        self.verticalScrollBar().scroll_to_min()

    def scroll_to_bottom(self):
        """Scroll to the bottom of the scroll area."""
        self.verticalScrollBar().scroll_to_max()

h_scrollbar writable property

v_scrollbar writable property

__init__(*args, **kwargs)

Source code in prettyqt\widgets\abstractscrollarea.py

def __init__(self, *args, **kwargs):
    super().__init__(*args, **kwargs)
    self.setHorizontalScrollBar(widgets.ScrollBar(parent=self))
    self.setVerticalScrollBar(widgets.ScrollBar(parent=self))

get_horizontal_scrollbar_policy()

Source code in prettyqt\widgets\abstractscrollarea.py

def get_horizontal_scrollbar_policy(self):
    return constants.SCROLLBAR_POLICY.inverse[self.horizontalScrollBarPolicy()]

get_size_adjust_policy() -> SizePolicyStr

Return size adjust policy.

Returns:

Type	Description
SizePolicyStr	size adjust policy

Source code in prettyqt\widgets\abstractscrollarea.py

def get_size_adjust_policy(self) -> SizePolicyStr:
    """Return size adjust policy.

    Returns:
        size adjust policy
    """
    return SIZE_POLICY.inverse[self.sizeAdjustPolicy()]

get_vertical_scrollbar_policy()

Source code in prettyqt\widgets\abstractscrollarea.py

def get_vertical_scrollbar_policy(self):
    return constants.SCROLLBAR_POLICY.inverse[self.verticalScrollBarPolicy()]

scroll_to_bottom()

Scroll to the bottom of the scroll area.

Source code in prettyqt\widgets\abstractscrollarea.py

def scroll_to_bottom(self):
    """Scroll to the bottom of the scroll area."""
    self.verticalScrollBar().scroll_to_max()

scroll_to_top()

Scroll to the top of the scroll area.

Source code in prettyqt\widgets\abstractscrollarea.py

def scroll_to_top(self):
    """Scroll to the top of the scroll area."""
    self.verticalScrollBar().scroll_to_min()

set_horizontal_scrollbar_policy(mode: constants.ScrollBarPolicyStr)

Set the horizontal scrollbar visibility.

Parameters:

Name	Type	Description	Default
mode	constants.ScrollBarPolicyStr	visibilty to set	required

Raises:

Type	Description
InvalidParamError	invalid scrollbar policy

Source code in prettyqt\widgets\abstractscrollarea.py

def set_horizontal_scrollbar_policy(self, mode: constants.ScrollBarPolicyStr):
    """Set the horizontal scrollbar visibility.

    Args:
        mode: visibilty to set

    Raises:
        InvalidParamError: invalid scrollbar policy
    """
    if mode not in constants.SCROLLBAR_POLICY:
        raise InvalidParamError(mode, constants.SCROLLBAR_POLICY)
    self.setHorizontalScrollBarPolicy(constants.SCROLLBAR_POLICY[mode])

set_horizontal_scrollbar_width(width: int)

Set the horizontal scrollbar width.

Parameters:

Name	Type	Description	Default
width	int	width in pixels	required

Source code in prettyqt\widgets\abstractscrollarea.py

def set_horizontal_scrollbar_width(self, width: int):
    """Set the horizontal scrollbar width.

    Args:
        width: width in pixels
    """
    with self.h_scrollbar.edit_stylesheet() as ss:
        ss.QScrollBar.horizontal.height.setValue(f"{width}px")

set_scrollbar_policy(mode: constants.ScrollBarPolicyStr)

Set the policy for both scrollbars.

Parameters:

Name	Type	Description	Default
mode	constants.ScrollBarPolicyStr	visibilty to set	required

Raises:

Type	Description
InvalidParamError	invalid scrollbar policy

Source code in prettyqt\widgets\abstractscrollarea.py

def set_scrollbar_policy(self, mode: constants.ScrollBarPolicyStr):
    """Set the policy for both scrollbars.

    Args:
        mode: visibilty to set

    Raises:
        InvalidParamError: invalid scrollbar policy
    """
    if mode not in constants.SCROLLBAR_POLICY:
        raise InvalidParamError(mode, constants.SCROLLBAR_POLICY)
    self.setHorizontalScrollBarPolicy(constants.SCROLLBAR_POLICY[mode])
    self.setVerticalScrollBarPolicy(constants.SCROLLBAR_POLICY[mode])

set_scrollbar_width(width: int)

Set the width for both scrollbars.

Parameters:

Name	Type	Description	Default
width	int	width in pixels	required

Source code in prettyqt\widgets\abstractscrollarea.py

def set_scrollbar_width(self, width: int):
    """Set the width for both scrollbars.

    Args:
        width: width in pixels
    """
    self.set_horizontal_scrollbar_width(width)
    self.set_vertical_scrollbar_width(width)

set_size_adjust_policy(policy: SizePolicyStr)

Set size adjust policy.

Parameters:

Name	Type	Description	Default
policy	SizePolicyStr	size adjust policy to use	required

Raises:

Type	Description
InvalidParamError	invalid size adjust policy

Source code in prettyqt\widgets\abstractscrollarea.py

def set_size_adjust_policy(self, policy: SizePolicyStr):
    """Set size adjust policy.

    Args:
        policy: size adjust policy to use

    Raises:
        InvalidParamError: invalid size adjust policy
    """
    if policy not in SIZE_POLICY:
        raise InvalidParamError(policy, SIZE_POLICY)
    self.setSizeAdjustPolicy(SIZE_POLICY[policy])

set_vertical_scrollbar_policy(mode: constants.ScrollBarPolicyStr)

Set the vertical scrollbar visibility.

Parameters:

Name	Type	Description	Default
mode	constants.ScrollBarPolicyStr	visibilty to set	required

Raises:

Type	Description
InvalidParamError	invalid scrollbar policy

Source code in prettyqt\widgets\abstractscrollarea.py

def set_vertical_scrollbar_policy(self, mode: constants.ScrollBarPolicyStr):
    """Set the vertical scrollbar visibility.

    Args:
        mode: visibilty to set

    Raises:
        InvalidParamError: invalid scrollbar policy
    """
    if mode not in constants.SCROLLBAR_POLICY:
        raise InvalidParamError(mode, constants.SCROLLBAR_POLICY)
    self.setVerticalScrollBarPolicy(constants.SCROLLBAR_POLICY[mode])

set_vertical_scrollbar_width(width: int)

Set the vertical scrollbar width.

Parameters:

Name	Type	Description	Default
width	int	width in pixels	required

Source code in prettyqt\widgets\abstractscrollarea.py

def set_vertical_scrollbar_width(self, width: int):
    """Set the vertical scrollbar width.

    Args:
        width: width in pixels
    """
    with self.v_scrollbar.edit_stylesheet() as ss:
        ss.QScrollBar.horizontal.height.setValue(f"{width}px")

AbstractSlider

Bases: AbstractSliderMixin, QtWidgets.QAbstractSlider

Source code in prettyqt\widgets\abstractslider.py

class AbstractSlider(AbstractSliderMixin, QtWidgets.QAbstractSlider):
    pass

AbstractSliderMixin

Bases: widgets.WidgetMixin

Source code in prettyqt\widgets\abstractslider.py

class AbstractSliderMixin(widgets.WidgetMixin):
    value_changed = core.Signal(int)

    def on_value_change(self):
        self.value_changed.emit(self.value())

    def is_horizontal(self) -> bool:
        """Check if silder is horizontal.

        Returns:
            True if horizontal, else False
        """
        return self.orientation() == constants.HORIZONTAL

    def is_vertical(self) -> bool:
        """Check if silder is vertical.

        Returns:
            True if vertical, else False
        """
        return self.orientation() == constants.VERTICAL

    def set_horizontal(self):
        """Set slider orientation to horizontal."""
        self.setOrientation(constants.HORIZONTAL)

    def set_vertical(self):
        """Set slider orientation to vertical."""
        self.setOrientation(constants.VERTICAL)

    def set_orientation(self, orientation: constants.OrientationStr):
        """Set the orientation of the slider.

        Args:
            orientation: orientation for the slider

        Raises:
            InvalidParamError: orientation does not exist
        """
        if orientation not in constants.ORIENTATION:
            raise InvalidParamError(orientation, constants.ORIENTATION)
        self.setOrientation(constants.ORIENTATION[orientation])

    def get_orientation(self) -> constants.OrientationStr:
        """Return current orientation.

        Returns:
            orientation
        """
        return constants.ORIENTATION.inverse[self.orientation()]

    def scroll_to_min(self):
        """Scroll to the minimum value of the slider."""
        self.setValue(self.minimum())

    def scroll_to_max(self):
        """Scroll to the maximum value of the slider."""
        self.setValue(self.maximum())

    def set_range(self, min_val: int, max_val: int):
        self.setRange(min_val, max_val)

    def set_step_size(self, step_size: int):
        self.setSingleStep(step_size)

    def set_repeat_action(
        self, action: SliderActionStr, threshold: int = 500, repeat_time: int = 50
    ):
        """Set the repeat action.

        Args:
            action: repeat action
            threshold: initial delay in ms
            repeat_time: repeat time in ms

        Raises:
            InvalidParamError: invalid repeat action
        """
        if action not in SLIDER_ACTION:
            raise InvalidParamError(action, SLIDER_ACTION)
        self.setRepeatAction(SLIDER_ACTION[action], threshold, repeat_time)

    def get_repeat_action(self) -> SliderActionStr:
        """Get current repeat action.

        Returns:
            current repeat action
        """
        return SLIDER_ACTION.inverse[self.repeatAction()]

    def trigger_action(self, action: SliderActionStr):
        """Trigger slider action."""
        if action not in SLIDER_ACTION:
            raise InvalidParamError(action, SLIDER_ACTION)
        self.triggerAction(SLIDER_ACTION[action])

    def get_value(self):
        return self.value()

    def set_value(self, value: int):
        self.setValue(value)

    def on_scrollbar_range_changed(self, minval, maxval):
        if self.value() >= self.maximum() - 1:
            self.setValue(maxval)

    def set_auto_scroll_to_end(self, scroll: bool = True):
        """Set to always scroll to the end when range changes."""
        if scroll:
            self.rangeChanged.connect(self.on_scrollbar_range_changed)
        else:
            self.rangeChanged.disconnect(self.on_scrollbar_range_changed)

value_changed = core.Signal(int) class-attribute

get_orientation() -> constants.OrientationStr

Return current orientation.

Returns:

Type	Description
constants.OrientationStr	orientation

Source code in prettyqt\widgets\abstractslider.py

def get_orientation(self) -> constants.OrientationStr:
    """Return current orientation.

    Returns:
        orientation
    """
    return constants.ORIENTATION.inverse[self.orientation()]

get_repeat_action() -> SliderActionStr

Get current repeat action.

Returns:

Type	Description
SliderActionStr	current repeat action

Source code in prettyqt\widgets\abstractslider.py

def get_repeat_action(self) -> SliderActionStr:
    """Get current repeat action.

    Returns:
        current repeat action
    """
    return SLIDER_ACTION.inverse[self.repeatAction()]

get_value()

Source code in prettyqt\widgets\abstractslider.py

def get_value(self):
    return self.value()

is_horizontal() -> bool

Check if silder is horizontal.

Returns:

Type	Description
bool	True if horizontal, else False

Source code in prettyqt\widgets\abstractslider.py

def is_horizontal(self) -> bool:
    """Check if silder is horizontal.

    Returns:
        True if horizontal, else False
    """
    return self.orientation() == constants.HORIZONTAL

is_vertical() -> bool

Check if silder is vertical.

Returns:

Type	Description
bool	True if vertical, else False

Source code in prettyqt\widgets\abstractslider.py

def is_vertical(self) -> bool:
    """Check if silder is vertical.

    Returns:
        True if vertical, else False
    """
    return self.orientation() == constants.VERTICAL

on_scrollbar_range_changed(minval, maxval)

Source code in prettyqt\widgets\abstractslider.py

def on_scrollbar_range_changed(self, minval, maxval):
    if self.value() >= self.maximum() - 1:
        self.setValue(maxval)

on_value_change()

Source code in prettyqt\widgets\abstractslider.py

def on_value_change(self):
    self.value_changed.emit(self.value())

scroll_to_max()

Scroll to the maximum value of the slider.

Source code in prettyqt\widgets\abstractslider.py

def scroll_to_max(self):
    """Scroll to the maximum value of the slider."""
    self.setValue(self.maximum())

scroll_to_min()

Scroll to the minimum value of the slider.

Source code in prettyqt\widgets\abstractslider.py

def scroll_to_min(self):
    """Scroll to the minimum value of the slider."""
    self.setValue(self.minimum())

set_auto_scroll_to_end(scroll: bool = True)

Set to always scroll to the end when range changes.

Source code in prettyqt\widgets\abstractslider.py

def set_auto_scroll_to_end(self, scroll: bool = True):
    """Set to always scroll to the end when range changes."""
    if scroll:
        self.rangeChanged.connect(self.on_scrollbar_range_changed)
    else:
        self.rangeChanged.disconnect(self.on_scrollbar_range_changed)

set_horizontal()

Set slider orientation to horizontal.

Source code in prettyqt\widgets\abstractslider.py

def set_horizontal(self):
    """Set slider orientation to horizontal."""
    self.setOrientation(constants.HORIZONTAL)

set_orientation(orientation: constants.OrientationStr)

Set the orientation of the slider.

Parameters:

Name	Type	Description	Default
orientation	constants.OrientationStr	orientation for the slider	required

Raises:

Type	Description
InvalidParamError	orientation does not exist

Source code in prettyqt\widgets\abstractslider.py

def set_orientation(self, orientation: constants.OrientationStr):
    """Set the orientation of the slider.

    Args:
        orientation: orientation for the slider

    Raises:
        InvalidParamError: orientation does not exist
    """
    if orientation not in constants.ORIENTATION:
        raise InvalidParamError(orientation, constants.ORIENTATION)
    self.setOrientation(constants.ORIENTATION[orientation])

set_range(min_val: int, max_val: int)

Source code in prettyqt\widgets\abstractslider.py

def set_range(self, min_val: int, max_val: int):
    self.setRange(min_val, max_val)

set_repeat_action(action: SliderActionStr, threshold: int = 500, repeat_time: int = 50)

Set the repeat action.

Parameters:

Name	Type	Description	Default
action	SliderActionStr	repeat action	required
threshold	int	initial delay in ms	500
repeat_time	int	repeat time in ms	50

Raises:

Type	Description
InvalidParamError	invalid repeat action

Source code in prettyqt\widgets\abstractslider.py

def set_repeat_action(
    self, action: SliderActionStr, threshold: int = 500, repeat_time: int = 50
):
    """Set the repeat action.

    Args:
        action: repeat action
        threshold: initial delay in ms
        repeat_time: repeat time in ms

    Raises:
        InvalidParamError: invalid repeat action
    """
    if action not in SLIDER_ACTION:
        raise InvalidParamError(action, SLIDER_ACTION)
    self.setRepeatAction(SLIDER_ACTION[action], threshold, repeat_time)

set_step_size(step_size: int)

Source code in prettyqt\widgets\abstractslider.py

def set_step_size(self, step_size: int):
    self.setSingleStep(step_size)

set_value(value: int)

Source code in prettyqt\widgets\abstractslider.py

def set_value(self, value: int):
    self.setValue(value)

set_vertical()

Set slider orientation to vertical.

Source code in prettyqt\widgets\abstractslider.py

def set_vertical(self):
    """Set slider orientation to vertical."""
    self.setOrientation(constants.VERTICAL)

trigger_action(action: SliderActionStr)

Trigger slider action.

Source code in prettyqt\widgets\abstractslider.py

def trigger_action(self, action: SliderActionStr):
    """Trigger slider action."""
    if action not in SLIDER_ACTION:
        raise InvalidParamError(action, SLIDER_ACTION)
    self.triggerAction(SLIDER_ACTION[action])

AbstractSpinBox

Bases: AbstractSpinBoxMixin, QtWidgets.QAbstractSpinBox

Source code in prettyqt\widgets\abstractspinbox.py

class AbstractSpinBox(AbstractSpinBoxMixin, QtWidgets.QAbstractSpinBox):
    pass

AbstractSpinBoxMixin

Bases: widgets.WidgetMixin

Source code in prettyqt\widgets\abstractspinbox.py

class AbstractSpinBoxMixin(widgets.WidgetMixin):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.setLineEdit(widgets.LineEdit())
        self.setGroupSeparatorShown(True)

    def is_valid(self) -> bool:
        return self.hasAcceptableInput()

    def set_validator(self, validator: gui.Validator):
        self.lineEdit().setValidator(validator)

    def get_button_symbols(self) -> SymbolStr:
        """Return button symbol type.

        Returns:
            button symbol type
        """
        return SYMBOLS.inverse[self.buttonSymbols()]

    def set_button_symbols(self, mode: SymbolStr):
        """Set button symbol type.

        Args:
            mode: button symbol type to use

        Raises:
            InvalidParamError: invalid button symbol type
        """
        if mode not in SYMBOLS:
            raise InvalidParamError(mode, SYMBOLS)
        self.setButtonSymbols(SYMBOLS[mode])

    def set_correction_mode(self, mode: CorrectionModeStr):
        """Set correction mode.

        Args:
            mode: correction mode to use

        Raises:
            InvalidParamError: invalid correction mode
        """
        if mode not in CORRECTION_MODES:
            raise InvalidParamError(mode, CORRECTION_MODES)
        self.setCorrectionMode(CORRECTION_MODES[mode])

    def get_correction_mode(self) -> CorrectionModeStr:
        """Return correction mode.

        Returns:
            correction mode
        """
        return CORRECTION_MODES.inverse[self.correctionMode()]

    def set_step_type(self, mode: StepTypeStr):
        """Set step type.

        Args:
            mode: step type to use

        Raises:
            InvalidParamError: invalid step type
        """
        if mode not in STEP_TYPES:
            raise InvalidParamError(mode, STEP_TYPES)
        self.setStepType(STEP_TYPES[mode])

    def get_step_type(self) -> StepTypeStr:
        """Return step type.

        Returns:
            step type
        """
        return STEP_TYPES.inverse[self.stepType()]

    def set_special_value(self, value: str):
        self.setSpecialValueText(value)

    def get_value(self) -> int:
        return self.value()

    def set_value(self, value: int | float):
        self.setValue(value)

__init__(*args, **kwargs)

Source code in prettyqt\widgets\abstractspinbox.py

def __init__(self, *args, **kwargs):
    super().__init__(*args, **kwargs)
    self.setLineEdit(widgets.LineEdit())
    self.setGroupSeparatorShown(True)

get_button_symbols() -> SymbolStr

Return button symbol type.

Returns:

Type	Description
SymbolStr	button symbol type

Source code in prettyqt\widgets\abstractspinbox.py

def get_button_symbols(self) -> SymbolStr:
    """Return button symbol type.

    Returns:
        button symbol type
    """
    return SYMBOLS.inverse[self.buttonSymbols()]

get_correction_mode() -> CorrectionModeStr

Return correction mode.

Returns:

Type	Description
CorrectionModeStr	correction mode

Source code in prettyqt\widgets\abstractspinbox.py

def get_correction_mode(self) -> CorrectionModeStr:
    """Return correction mode.

    Returns:
        correction mode
    """
    return CORRECTION_MODES.inverse[self.correctionMode()]

get_step_type() -> StepTypeStr

Return step type.

Returns:

Type	Description
StepTypeStr	step type

Source code in prettyqt\widgets\abstractspinbox.py

def get_step_type(self) -> StepTypeStr:
    """Return step type.

    Returns:
        step type
    """
    return STEP_TYPES.inverse[self.stepType()]

get_value() -> int

Source code in prettyqt\widgets\abstractspinbox.py

def get_value(self) -> int:
    return self.value()

is_valid() -> bool

Source code in prettyqt\widgets\abstractspinbox.py

def is_valid(self) -> bool:
    return self.hasAcceptableInput()

set_button_symbols(mode: SymbolStr)

Set button symbol type.

Parameters:

Name	Type	Description	Default
mode	SymbolStr	button symbol type to use	required

Raises:

Type	Description
InvalidParamError	invalid button symbol type

Source code in prettyqt\widgets\abstractspinbox.py

def set_button_symbols(self, mode: SymbolStr):
    """Set button symbol type.

    Args:
        mode: button symbol type to use

    Raises:
        InvalidParamError: invalid button symbol type
    """
    if mode not in SYMBOLS:
        raise InvalidParamError(mode, SYMBOLS)
    self.setButtonSymbols(SYMBOLS[mode])

set_correction_mode(mode: CorrectionModeStr)

Set correction mode.

Parameters:

Name	Type	Description	Default
mode	CorrectionModeStr	correction mode to use	required

Raises:

Type	Description
InvalidParamError	invalid correction mode

Source code in prettyqt\widgets\abstractspinbox.py

def set_correction_mode(self, mode: CorrectionModeStr):
    """Set correction mode.

    Args:
        mode: correction mode to use

    Raises:
        InvalidParamError: invalid correction mode
    """
    if mode not in CORRECTION_MODES:
        raise InvalidParamError(mode, CORRECTION_MODES)
    self.setCorrectionMode(CORRECTION_MODES[mode])

set_special_value(value: str)

Source code in prettyqt\widgets\abstractspinbox.py

def set_special_value(self, value: str):
    self.setSpecialValueText(value)

set_step_type(mode: StepTypeStr)

Set step type.

Parameters:

Name	Type	Description	Default
mode	StepTypeStr	step type to use	required

Raises:

Type	Description
InvalidParamError	invalid step type

Source code in prettyqt\widgets\abstractspinbox.py

def set_step_type(self, mode: StepTypeStr):
    """Set step type.

    Args:
        mode: step type to use

    Raises:
        InvalidParamError: invalid step type
    """
    if mode not in STEP_TYPES:
        raise InvalidParamError(mode, STEP_TYPES)
    self.setStepType(STEP_TYPES[mode])

set_validator(validator: gui.Validator)

Source code in prettyqt\widgets\abstractspinbox.py

def set_validator(self, validator: gui.Validator):
    self.lineEdit().setValidator(validator)

set_value(value: int | float)

Source code in prettyqt\widgets\abstractspinbox.py

def set_value(self, value: int | float):
    self.setValue(value)

Action

Bases: ActionMixin, prettyprinter.PrettyPrinter, QtWidgets.QAction

Source code in prettyqt\widgets\action.py

class Action(ActionMixin, prettyprinter.PrettyPrinter, QtWidgets.QAction):
    pass

ActionGroup

Bases: core.ObjectMixin, QtWidgets.QActionGroup

Source code in prettyqt\widgets\actiongroup.py

class ActionGroup(core.ObjectMixin, QtWidgets.QActionGroup):
    def __init__(self, parent: QtCore.QObject | None = None):
        super().__init__(parent)  # type: ignore

    def __len__(self) -> int:
        return len(self.actions())

    def __getitem__(self, item: int) -> QtWidgets.QAction:
        return self.actions()[item]

    def set_exclusion_policy(self, policy: ExclusionPolicyStr | None):
        """Set exclusion policy to use.

        Args:
            policy: exclusion policy to use

        Raises:
            InvalidParamError: exclusion policy does not exist
        """
        if policy is None:
            policy = "none"
        if policy not in POLICIES:
            raise InvalidParamError(policy, POLICIES)
        self.setExclusionPolicy(POLICIES[policy])

    def get_exclusion_policy(self) -> ExclusionPolicyStr:
        """Return current exclusion policy.

        Returns:
            exclusion policy
        """
        return POLICIES.inverse[self.exclusionPolicy()]

__getitem__(item: int) -> QtWidgets.QAction

Source code in prettyqt\widgets\actiongroup.py

def __getitem__(self, item: int) -> QtWidgets.QAction:
    return self.actions()[item]

__init__(parent: QtCore.QObject | None = None)

Source code in prettyqt\widgets\actiongroup.py

def __init__(self, parent: QtCore.QObject | None = None):
    super().__init__(parent)  # type: ignore

__len__() -> int

Source code in prettyqt\widgets\actiongroup.py

def __len__(self) -> int:
    return len(self.actions())

get_exclusion_policy() -> ExclusionPolicyStr

Return current exclusion policy.

Returns:

Type	Description
ExclusionPolicyStr	exclusion policy

Source code in prettyqt\widgets\actiongroup.py

def get_exclusion_policy(self) -> ExclusionPolicyStr:
    """Return current exclusion policy.

    Returns:
        exclusion policy
    """
    return POLICIES.inverse[self.exclusionPolicy()]

set_exclusion_policy(policy: ExclusionPolicyStr | None)

Set exclusion policy to use.

Parameters:

Name	Type	Description	Default
policy	ExclusionPolicyStr | None	exclusion policy to use	required

Raises:

Type	Description
InvalidParamError	exclusion policy does not exist

Source code in prettyqt\widgets\actiongroup.py

def set_exclusion_policy(self, policy: ExclusionPolicyStr | None):
    """Set exclusion policy to use.

    Args:
        policy: exclusion policy to use

    Raises:
        InvalidParamError: exclusion policy does not exist
    """
    if policy is None:
        policy = "none"
    if policy not in POLICIES:
        raise InvalidParamError(policy, POLICIES)
    self.setExclusionPolicy(POLICIES[policy])

ActionMixin

Bases: core.ObjectMixin

Source code in prettyqt\widgets\action.py

class ActionMixin(core.ObjectMixin):
    def __init__(
        self,
        parent: QtCore.QObject | None = None,
        text: str = "",
        icon: datatypes.IconType = None,
        shortcut: str | None = None,
        tooltip: str = "",
        checkable: bool = False,
        checked: bool = False,
        statustip: str = "",
        enabled: bool = True,
        callback: Callable | None = None,
    ):
        super().__init__(parent)
        self._menu = None
        self.set_text(text)
        self.set_icon(icon)
        self.set_shortcut(shortcut)
        self.set_tooltip(tooltip)
        self.set_checkable(checkable)
        self.set_checked(checked)
        self.set_statustip(statustip)
        self.set_enabled(enabled)
        if callback is not None:
            self.triggered.connect(callback)

    def __repr__(self) -> str:
        return get_repr(self, self.text())

    def set_text(self, text: str):
        self.setText(text)

    def set_enabled(self, enabled: bool = True):
        self.setEnabled(enabled)

    def set_disabled(self):
        self.setEnabled(False)

    def set_tooltip(
        self,
        tooltip: str | datatypes.PathType,
        size: datatypes.SizeType | None = None,
    ):
        if isinstance(tooltip, os.PathLike):
            path = os.fspath(tooltip)
            if size is None:
                tooltip = f"<img src={path!r}>"
            else:
                if isinstance(size, QtCore.QSize):
                    size = (size.width(), size.height())
                tooltip = f'<img src={path!r} width="{size[0]}" height="{size[1]}">'
        self.setToolTip(tooltip)

    def set_statustip(self, text: str):
        self.setStatusTip(text)

    def set_checked(self, value: bool):
        self.setChecked(value)

    def set_checkable(self, value: bool):
        self.setCheckable(value)

    def set_icon(self, icon: datatypes.IconType):
        """Set the icon for the action.

        Args:
            icon: icon to use
        """
        icon = iconprovider.get_icon(icon)
        self.setIcon(icon)

    def get_icon(self) -> gui.Icon | None:
        icon = self.icon()
        return None if icon.isNull() else gui.Icon(icon)

    def set_shortcut(self, shortcut: None | QtGui.QKeySequence | str):
        if shortcut is None:
            shortcut = ""
        if isinstance(shortcut, str):
            shortcut = gui.KeySequence(
                shortcut, gui.KeySequence.SequenceFormat.PortableText
            )
        self.setShortcut(shortcut)

    def get_shortcut(self) -> gui.KeySequence | None:
        shortcut = self.shortcut()
        return (
            gui.KeySequence(
                shortcut.toString(), gui.KeySequence.SequenceFormat.PortableText
            )
            if shortcut
            else None
        )

    def get_font(self) -> gui.Font:
        return gui.Font(self.font())

    def set_menu(self, menu):
        try:
            self.setMenu(menu)
        except AttributeError:
            self.triggered.connect(menu.exec)
            self._menu = menu

    def menu(self):
        return self._menu

    def set_priority(self, priority: PriorityStr):
        """Set priority of the action.

        Args:
            priority: priority for the action

        Raises:
            InvalidParamError: priority does not exist
        """
        if priority not in PRIORITIES:
            raise InvalidParamError(priority, PRIORITIES)
        self.setPriority(PRIORITIES[priority])

    def get_priority(self) -> PriorityStr:
        """Return current priority.

        Returns:
            priority
        """
        return PRIORITIES.inverse[self.priority()]

    def set_shortcut_context(self, context: constants.ContextStr):
        """Set shortcut context.

        Args:
            context: shortcut context

        Raises:
            InvalidParamError: shortcut context does not exist
        """
        if context not in constants.CONTEXT:
            raise InvalidParamError(context, constants.CONTEXT)
        self.setShortcutContext(constants.CONTEXT[context])

    def get_shortcut_context(self) -> constants.ContextStr:
        """Return shortcut context.

        Returns:
            shortcut context
        """
        return constants.CONTEXT.inverse[self.shortcutContext()]

    def set_menu_role(self, role: RoleStr):
        """Set menu role.

        Args:
            role: menu role

        Raises:
            InvalidParamError: menu role does not exist
        """
        if role not in ROLES:
            raise InvalidParamError(role, ROLES)
        self.setMenuRole(ROLES[role])

    def get_menu_role(self) -> RoleStr:
        """Return menu role.

        Returns:
            menu role
        """
        return ROLES.inverse[self.menuRole()]

    def show_shortcut_in_contextmenu(self, state: bool = True):
        self.setShortcutVisibleInContextMenu(state)

__init__(parent: QtCore.QObject | None = None, text: str = '', icon: datatypes.IconType = None, shortcut: str | None = None, tooltip: str = '', checkable: bool = False, checked: bool = False, statustip: str = '', enabled: bool = True, callback: Callable | None = None)

Source code in prettyqt\widgets\action.py

def __init__(
    self,
    parent: QtCore.QObject | None = None,
    text: str = "",
    icon: datatypes.IconType = None,
    shortcut: str | None = None,
    tooltip: str = "",
    checkable: bool = False,
    checked: bool = False,
    statustip: str = "",
    enabled: bool = True,
    callback: Callable | None = None,
):
    super().__init__(parent)
    self._menu = None
    self.set_text(text)
    self.set_icon(icon)
    self.set_shortcut(shortcut)
    self.set_tooltip(tooltip)
    self.set_checkable(checkable)
    self.set_checked(checked)
    self.set_statustip(statustip)
    self.set_enabled(enabled)
    if callback is not None:
        self.triggered.connect(callback)

__repr__() -> str

Source code in prettyqt\widgets\action.py

def __repr__(self) -> str:
    return get_repr(self, self.text())

get_font() -> gui.Font

Source code in prettyqt\widgets\action.py

def get_font(self) -> gui.Font:
    return gui.Font(self.font())

get_icon() -> gui.Icon | None

Source code in prettyqt\widgets\action.py

def get_icon(self) -> gui.Icon | None:
    icon = self.icon()
    return None if icon.isNull() else gui.Icon(icon)

get_menu_role() -> RoleStr

Return menu role.

Returns:

Type	Description
RoleStr	menu role

Source code in prettyqt\widgets\action.py

def get_menu_role(self) -> RoleStr:
    """Return menu role.

    Returns:
        menu role
    """
    return ROLES.inverse[self.menuRole()]

get_priority() -> PriorityStr

Return current priority.

Returns:

Type	Description
PriorityStr	priority

Source code in prettyqt\widgets\action.py

def get_priority(self) -> PriorityStr:
    """Return current priority.

    Returns:
        priority
    """
    return PRIORITIES.inverse[self.priority()]

get_shortcut() -> gui.KeySequence | None

Source code in prettyqt\widgets\action.py

def get_shortcut(self) -> gui.KeySequence | None:
    shortcut = self.shortcut()
    return (
        gui.KeySequence(
            shortcut.toString(), gui.KeySequence.SequenceFormat.PortableText
        )
        if shortcut
        else None
    )

get_shortcut_context() -> constants.ContextStr

Return shortcut context.

Returns:

Type	Description
constants.ContextStr	shortcut context

Source code in prettyqt\widgets\action.py

def get_shortcut_context(self) -> constants.ContextStr:
    """Return shortcut context.

    Returns:
        shortcut context
    """
    return constants.CONTEXT.inverse[self.shortcutContext()]

menu()

Source code in prettyqt\widgets\action.py

def menu(self):
    return self._menu

set_checkable(value: bool)

Source code in prettyqt\widgets\action.py

def set_checkable(self, value: bool):
    self.setCheckable(value)

set_checked(value: bool)

Source code in prettyqt\widgets\action.py

def set_checked(self, value: bool):
    self.setChecked(value)

set_disabled()

Source code in prettyqt\widgets\action.py

def set_disabled(self):
    self.setEnabled(False)

set_enabled(enabled: bool = True)

Source code in prettyqt\widgets\action.py

def set_enabled(self, enabled: bool = True):
    self.setEnabled(enabled)

set_icon(icon: datatypes.IconType)

Set the icon for the action.

Parameters:

Name	Type	Description	Default
icon	datatypes.IconType	icon to use	required

Source code in prettyqt\widgets\action.py

def set_icon(self, icon: datatypes.IconType):
    """Set the icon for the action.

    Args:
        icon: icon to use
    """
    icon = iconprovider.get_icon(icon)
    self.setIcon(icon)

set_menu(menu)

Source code in prettyqt\widgets\action.py

def set_menu(self, menu):
    try:
        self.setMenu(menu)
    except AttributeError:
        self.triggered.connect(menu.exec)
        self._menu = menu

set_menu_role(role: RoleStr)

Set menu role.

Parameters:

Name	Type	Description	Default
role	RoleStr	menu role	required

Raises:

Type	Description
InvalidParamError	menu role does not exist

Source code in prettyqt\widgets\action.py

def set_menu_role(self, role: RoleStr):
    """Set menu role.

    Args:
        role: menu role

    Raises:
        InvalidParamError: menu role does not exist
    """
    if role not in ROLES:
        raise InvalidParamError(role, ROLES)
    self.setMenuRole(ROLES[role])

set_priority(priority: PriorityStr)

Set priority of the action.

Parameters:

Name	Type	Description	Default
priority	PriorityStr	priority for the action	required

Raises:

Type	Description
InvalidParamError	priority does not exist

Source code in prettyqt\widgets\action.py

def set_priority(self, priority: PriorityStr):
    """Set priority of the action.

    Args:
        priority: priority for the action

    Raises:
        InvalidParamError: priority does not exist
    """
    if priority not in PRIORITIES:
        raise InvalidParamError(priority, PRIORITIES)
    self.setPriority(PRIORITIES[priority])

set_shortcut(shortcut: None | QtGui.QKeySequence | str)

Source code in prettyqt\widgets\action.py

def set_shortcut(self, shortcut: None | QtGui.QKeySequence | str):
    if shortcut is None:
        shortcut = ""
    if isinstance(shortcut, str):
        shortcut = gui.KeySequence(
            shortcut, gui.KeySequence.SequenceFormat.PortableText
        )
    self.setShortcut(shortcut)

set_shortcut_context(context: constants.ContextStr)

Set shortcut context.

Parameters:

Name	Type	Description	Default
context	constants.ContextStr	shortcut context	required

Raises:

Type	Description
InvalidParamError	shortcut context does not exist

Source code in prettyqt\widgets\action.py

def set_shortcut_context(self, context: constants.ContextStr):
    """Set shortcut context.

    Args:
        context: shortcut context

    Raises:
        InvalidParamError: shortcut context does not exist
    """
    if context not in constants.CONTEXT:
        raise InvalidParamError(context, constants.CONTEXT)
    self.setShortcutContext(constants.CONTEXT[context])

set_statustip(text: str)

Source code in prettyqt\widgets\action.py

def set_statustip(self, text: str):
    self.setStatusTip(text)

set_text(text: str)

Source code in prettyqt\widgets\action.py

def set_text(self, text: str):
    self.setText(text)

set_tooltip(tooltip: str | datatypes.PathType, size: datatypes.SizeType | None = None)

Source code in prettyqt\widgets\action.py

def set_tooltip(
    self,
    tooltip: str | datatypes.PathType,
    size: datatypes.SizeType | None = None,
):
    if isinstance(tooltip, os.PathLike):
        path = os.fspath(tooltip)
        if size is None:
            tooltip = f"<img src={path!r}>"
        else:
            if isinstance(size, QtCore.QSize):
                size = (size.width(), size.height())
            tooltip = f'<img src={path!r} width="{size[0]}" height="{size[1]}">'
    self.setToolTip(tooltip)

show_shortcut_in_contextmenu(state: bool = True)

Source code in prettyqt\widgets\action.py

def show_shortcut_in_contextmenu(self, state: bool = True):
    self.setShortcutVisibleInContextMenu(state)

Application

Bases: ApplicationMixin, QtWidgets.QApplication

Source code in prettyqt\widgets\application.py

class Application(ApplicationMixin, QtWidgets.QApplication):
    pass

BoxLayout

Bases: BoxLayoutMixin, QtWidgets.QBoxLayout

Source code in prettyqt\widgets\boxlayout.py

class BoxLayout(BoxLayoutMixin, QtWidgets.QBoxLayout):
    pass

ButtonGroup

Bases: core.ObjectMixin, QtWidgets.QButtonGroup

Source code in prettyqt\widgets\buttongroup.py

class ButtonGroup(core.ObjectMixin, QtWidgets.QButtonGroup):
    def serialize_fields(self):
        return dict(exclusive=self.exclusive())

    def __getitem__(self, index: int) -> QtWidgets.QAbstractButton:
        return self.button(index)

__getitem__(index: int) -> QtWidgets.QAbstractButton

Source code in prettyqt\widgets\buttongroup.py

def __getitem__(self, index: int) -> QtWidgets.QAbstractButton:
    return self.button(index)

serialize_fields()

Source code in prettyqt\widgets\buttongroup.py

def serialize_fields(self):
    return dict(exclusive=self.exclusive())

CalendarWidget

Bases: widgets.WidgetMixin, QtWidgets.QCalendarWidget

Source code in prettyqt\widgets\calendarwidget.py

class CalendarWidget(widgets.WidgetMixin, QtWidgets.QCalendarWidget):
    def get_date(self) -> datetime.date:
        return self.selectedDate().toPython()  # type: ignore

    def get_value(self) -> datetime.date:
        return self.get_date()

    def set_value(self, value: datatypes.DateType):
        if isinstance(value, str):
            value = QtCore.QDate.fromString(value)
        self.setSelectedDate(value)  # type: ignore

    def set_range(
        self,
        lower: datatypes.DateType,
        upper: datatypes.DateType,
    ):
        if isinstance(lower, str):
            lower = QtCore.QDate.fromString(lower)
        if isinstance(upper, str):
            upper = QtCore.QDate.fromString(upper)
        self.setMinimumDate(lower)  # type: ignore
        self.setMaximumDate(upper)  # type: ignore

    def set_selection_mode(self, mode: SelectionModeStr | None):
        """Set selection mode for given calendar widget.

        Args:
            mode: selection mode to use

        Raises:
            InvalidParamError: mode does not exist
        """
        if mode is None:
            mode = "none"
        if mode not in SELECTION_MODE:
            raise InvalidParamError(mode, SELECTION_MODE)
        self.setSelectionMode(SELECTION_MODE[mode])

    def get_selection_mode(self) -> SelectionModeStr:
        """Return current selection mode.

        Returns:
            selection mode
        """
        return SELECTION_MODE.inverse[self.selectionMode()]

get_date() -> datetime.date

Source code in prettyqt\widgets\calendarwidget.py

def get_date(self) -> datetime.date:
    return self.selectedDate().toPython()  # type: ignore

get_selection_mode() -> SelectionModeStr

Return current selection mode.

Returns:

Type	Description
SelectionModeStr	selection mode

Source code in prettyqt\widgets\calendarwidget.py

def get_selection_mode(self) -> SelectionModeStr:
    """Return current selection mode.

    Returns:
        selection mode
    """
    return SELECTION_MODE.inverse[self.selectionMode()]

get_value() -> datetime.date

Source code in prettyqt\widgets\calendarwidget.py

def get_value(self) -> datetime.date:
    return self.get_date()

set_range(lower: datatypes.DateType, upper: datatypes.DateType)

Source code in prettyqt\widgets\calendarwidget.py

def set_range(
    self,
    lower: datatypes.DateType,
    upper: datatypes.DateType,
):
    if isinstance(lower, str):
        lower = QtCore.QDate.fromString(lower)
    if isinstance(upper, str):
        upper = QtCore.QDate.fromString(upper)
    self.setMinimumDate(lower)  # type: ignore
    self.setMaximumDate(upper)  # type: ignore

set_selection_mode(mode: SelectionModeStr | None)

Set selection mode for given calendar widget.

Parameters:

Name	Type	Description	Default
mode	SelectionModeStr | None	selection mode to use	required

Raises:

Type	Description
InvalidParamError	mode does not exist

Source code in prettyqt\widgets\calendarwidget.py

def set_selection_mode(self, mode: SelectionModeStr | None):
    """Set selection mode for given calendar widget.

    Args:
        mode: selection mode to use

    Raises:
        InvalidParamError: mode does not exist
    """
    if mode is None:
        mode = "none"
    if mode not in SELECTION_MODE:
        raise InvalidParamError(mode, SELECTION_MODE)
    self.setSelectionMode(SELECTION_MODE[mode])

set_value(value: datatypes.DateType)

Source code in prettyqt\widgets\calendarwidget.py

def set_value(self, value: datatypes.DateType):
    if isinstance(value, str):
        value = QtCore.QDate.fromString(value)
    self.setSelectedDate(value)  # type: ignore

CheckBox

Bases: widgets.AbstractButtonMixin, QtWidgets.QCheckBox

Source code in prettyqt\widgets\checkbox.py

class CheckBox(widgets.AbstractButtonMixin, QtWidgets.QCheckBox):
    value_changed = core.Signal(int)

    def __init__(
        self,
        label: str = "",
        parent: QtWidgets.QWidget | None = None,
        checked: bool = False,
    ):
        super().__init__(label, parent)
        self.stateChanged.connect(self.value_changed)
        self.setChecked(checked)

    def set_checkstate(self, state: constants.StateStr):
        """Set checkstate of the checkbox.

        Args:
            state: checkstate to use

        Raises:
            InvalidParamError: invalid checkstate
        """
        if state not in constants.STATE:
            raise InvalidParamError(state, constants.STATE)
        self.setCheckState(constants.STATE[state])

    def get_checkstate(self) -> constants.StateStr:
        """Return checkstate.

        Returns:
            checkstate
        """
        return constants.STATE.inverse[self.checkState()]

value_changed = core.Signal(int) class-attribute

__init__(label: str = '', parent: QtWidgets.QWidget | None = None, checked: bool = False)

Source code in prettyqt\widgets\checkbox.py

def __init__(
    self,
    label: str = "",
    parent: QtWidgets.QWidget | None = None,
    checked: bool = False,
):
    super().__init__(label, parent)
    self.stateChanged.connect(self.value_changed)
    self.setChecked(checked)

get_checkstate() -> constants.StateStr

Return checkstate.

Returns:

Type	Description
constants.StateStr	checkstate

Source code in prettyqt\widgets\checkbox.py

def get_checkstate(self) -> constants.StateStr:
    """Return checkstate.

    Returns:
        checkstate
    """
    return constants.STATE.inverse[self.checkState()]

set_checkstate(state: constants.StateStr)

Set checkstate of the checkbox.

Parameters:

Name	Type	Description	Default
state	constants.StateStr	checkstate to use	required

Raises:

Type	Description
InvalidParamError	invalid checkstate

Source code in prettyqt\widgets\checkbox.py

def set_checkstate(self, state: constants.StateStr):
    """Set checkstate of the checkbox.

    Args:
        state: checkstate to use

    Raises:
        InvalidParamError: invalid checkstate
    """
    if state not in constants.STATE:
        raise InvalidParamError(state, constants.STATE)
    self.setCheckState(constants.STATE[state])

ColorDialog

Bases: widgets.DialogMixin, QtWidgets.QColorDialog

Source code in prettyqt\widgets\colordialog.py

class ColorDialog(widgets.DialogMixin, QtWidgets.QColorDialog):
    @classmethod
    def get_color(
        cls,
        preset: datatypes.ColorType = None,
        allow_alpha: bool = False,
        parent: QtWidgets.QWidget | None = None,
    ) -> gui.Color:
        preset = colors.get_color(preset)
        kwargs = (
            dict(options=cls.ColorDialogOption.ShowAlphaChannel) if allow_alpha else {}
        )
        color = cls.getColor(preset, parent, **kwargs)  # type: ignore
        return gui.Color(color)

    def current_color(self) -> gui.Color:
        return gui.Color(self.currentColor())

    def get_qcolorshower(self) -> QtWidgets.QWidget:
        return [
            a
            for a in self.children()
            if hasattr(a, "metaObject") and a.metaObject().className() == "QColorShower"
        ][0]

    def get_qcolorshowlabel(self) -> QtWidgets.QFrame:
        qcs = self.get_qcolorshower()
        return [
            b
            for b in qcs.children()
            if hasattr(b, "metaObject")
            and b.metaObject().className() == "QColorShowLabel"
        ][0]

    def replace_qcolorshowlabel(self, widget: QtWidgets.QWidget):
        # Find the dialog widget used to display the current
        # color, so we can replace it with our implementation
        qcs = self.get_qcolorshower()
        qcsl = self.get_qcolorshowlabel()
        qcs.layout().replaceWidget(qcsl, widget)
        # Make sure it doesn't receive signals while hidden
        qcsl.blockSignals(True)
        qcsl.hide()
        widget.show()

    def use_alpha_channel(self, value: bool = True):
        self.setOption(self.ColorDialogOption.ShowAlphaChannel, value)

    def hide_buttons(self, value: bool = True):
        self.setOption(self.ColorDialogOption.NoButtons, value)

    def use_native_dialog(self, value: bool = True):
        self.setOption(self.ColorDialogOption.DontUseNativeDialog, not value)

current_color() -> gui.Color

Source code in prettyqt\widgets\colordialog.py

def current_color(self) -> gui.Color:
    return gui.Color(self.currentColor())

get_color(preset: datatypes.ColorType = None, allow_alpha: bool = False, parent: QtWidgets.QWidget | None = None) -> gui.Color classmethod

Source code in prettyqt\widgets\colordialog.py

@classmethod
def get_color(
    cls,
    preset: datatypes.ColorType = None,
    allow_alpha: bool = False,
    parent: QtWidgets.QWidget | None = None,
) -> gui.Color:
    preset = colors.get_color(preset)
    kwargs = (
        dict(options=cls.ColorDialogOption.ShowAlphaChannel) if allow_alpha else {}
    )
    color = cls.getColor(preset, parent, **kwargs)  # type: ignore
    return gui.Color(color)

get_qcolorshower() -> QtWidgets.QWidget

Source code in prettyqt\widgets\colordialog.py

def get_qcolorshower(self) -> QtWidgets.QWidget:
    return [
        a
        for a in self.children()
        if hasattr(a, "metaObject") and a.metaObject().className() == "QColorShower"
    ][0]

get_qcolorshowlabel() -> QtWidgets.QFrame

Source code in prettyqt\widgets\colordialog.py

def get_qcolorshowlabel(self) -> QtWidgets.QFrame:
    qcs = self.get_qcolorshower()
    return [
        b
        for b in qcs.children()
        if hasattr(b, "metaObject")
        and b.metaObject().className() == "QColorShowLabel"
    ][0]

hide_buttons(value: bool = True)

Source code in prettyqt\widgets\colordialog.py

def hide_buttons(self, value: bool = True):
    self.setOption(self.ColorDialogOption.NoButtons, value)

replace_qcolorshowlabel(widget: QtWidgets.QWidget)

Source code in prettyqt\widgets\colordialog.py

def replace_qcolorshowlabel(self, widget: QtWidgets.QWidget):
    # Find the dialog widget used to display the current
    # color, so we can replace it with our implementation
    qcs = self.get_qcolorshower()
    qcsl = self.get_qcolorshowlabel()
    qcs.layout().replaceWidget(qcsl, widget)
    # Make sure it doesn't receive signals while hidden
    qcsl.blockSignals(True)
    qcsl.hide()
    widget.show()

use_alpha_channel(value: bool = True)

Source code in prettyqt\widgets\colordialog.py

def use_alpha_channel(self, value: bool = True):
    self.setOption(self.ColorDialogOption.ShowAlphaChannel, value)

use_native_dialog(value: bool = True)

Source code in prettyqt\widgets\colordialog.py

def use_native_dialog(self, value: bool = True):
    self.setOption(self.ColorDialogOption.DontUseNativeDialog, not value)

ColumnView

Bases: widgets.AbstractItemViewMixin, QtWidgets.QColumnView

Source code in prettyqt\widgets\columnview.py

class ColumnView(widgets.AbstractItemViewMixin, QtWidgets.QColumnView):
    pass

ComboBox

Bases: ComboBoxMixin, QtWidgets.QComboBox

Source code in prettyqt\widgets\combobox.py

class ComboBox(ComboBoxMixin, QtWidgets.QComboBox):
    pass

ComboBoxMixin

Bases: widgets.WidgetMixin

Source code in prettyqt\widgets\combobox.py

class ComboBoxMixin(widgets.WidgetMixin):
    value_changed = core.Signal(object)

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.currentIndexChanged.connect(self.index_changed)

    # def serialize_fields(self):
    #     items = [
    #         (self.itemText(i), self.itemData(i), self.item_icon(i))
    #         for i in range(self.count())
    #     ]
    #     return dict(
    #         index=self.currentIndex(),
    #         editable=self.isEditable(),
    #         max_count=self.maxCount(),
    #         has_frame=self.hasFrame(),
    #         icon_size=self.iconSize(),
    #         insert_policy=self.insertPolicy(),
    #         model_column=self.modelColumn(),
    #         max_visible_items=self.maxVisibleItems(),
    #         size_adjust_policy=self.get_size_adjust_policy(),
    #         duplicates_enabled=self.duplicatesEnabled(),
    #         min_contents_length=self.minimumContentsLength(),
    #         placeholder_text=self.placeholderText(),
    #         items=items,
    #     )

    # def __setstate__(self, state):
    #     super().__setstate__(state)
    #     for label, data, icon in state["items"]:
    #         self.add(label, data, icon=icon)
    #     self.setCurrentIndex(state["index"])
    #     self.setEditable(state["editable"])
    #     self.setMaxCount(state["max_count"])
    #     self.setMaxVisibleItems(state["max_visible_items"])
    #     self.setMinimumContentsLength(state["min_contents_length"])
    #     self.setDuplicatesEnabled(state["duplicates_enabled"])
    #     self.setFrame(state["has_frame"])

    # def __reduce__(self):
    #     return type(self), (), self.__getstate__()

    def __len__(self) -> int:
        return self.count()

    def index_changed(self, index: int):
        data = self.itemData(index)
        self.value_changed.emit(data)

    def add_items(self, items: Iterable | Mapping, default=NoData):
        if isinstance(items, Mapping):
            for k, v in items.items():
                self.addItem(v, userData=k)
        else:
            for i in items:
                if isinstance(i, tuple | list):
                    self.add(*i)
                else:
                    self.addItem(i, i)
        if default is not NoData:
            self.set_value(default)

    def add(self, label: str, data=NoData, icon: datatypes.IconType = None):
        if data is NoData:
            data = label
        if icon is not None:
            icon = iconprovider.get_icon(icon)
            self.addItem(gui.Icon(icon), label, userData=data)
        else:
            self.addItem(label, userData=data)

    def item_icon(self, index: int) -> gui.Icon | None:
        icon = self.itemIcon(index)
        return None if icon.isNull() else gui.Icon(icon)

    def set_editable(self, editable: bool):
        self.setEditable(editable)
        if self.completer() is None and editable:
            self.setCompleter(widgets.Completer(self))

    def set_insert_policy(self, policy: InsertPolicyStr):
        """Set insert policy.

        Args:
            policy: insert policy to use

        Raises:
            InvalidParamError: invalid insert policy
        """
        if policy not in INSERT_POLICY:
            raise InvalidParamError(policy, INSERT_POLICY)
        self.setInsertPolicy(INSERT_POLICY[policy])

    def get_insert_policy(self) -> InsertPolicyStr:
        """Return insert policy.

        Returns:
            insert policy
        """
        return INSERT_POLICY.inverse[self.insertPolicy()]

    def set_size_adjust_policy(self, policy: SizeAdjustPolicyStr):
        """Set size adjust policy.

        Args:
            policy: size adjust policy to use

        Raises:
            InvalidParamError: invalid size adjust policy
        """
        if policy not in SIZE_ADJUST_POLICY:
            raise InvalidParamError(policy, SIZE_ADJUST_POLICY)
        self.setSizeAdjustPolicy(SIZE_ADJUST_POLICY[policy])

    def get_size_adjust_policy(self) -> SizeAdjustPolicyStr:
        """Return size adjust policy.

        Returns:
            size adjust policy
        """
        return SIZE_ADJUST_POLICY.inverse[self.sizeAdjustPolicy()]

    def set_icon_size(self, size: int | datatypes.SizeType):
        """Set size of the icons."""
        if isinstance(size, int):
            size = core.Size(size, size)
        elif isinstance(size, tuple):
            size = core.Size(*size)
        self.setIconSize(size)

    def get_icon_size(self) -> core.Size:
        return core.Size(self.iconSize())

    def set_min_char_length(self, chars: int):
        self.setMinimumContentsLength(chars)

    def get_value(self) -> Any:
        # if all(self.itemData(i) is None for i in range(self.count())):
        #     return self.currentText()
        # else:
        #     return self.currentData()
        return self.currentData()

    def set_value(self, value: Any):
        self.set_data(value)

    def set_text(self, text: str):
        self.setCurrentText(text)

    def set_data(self, data: Any):
        idx = self.findData(data)
        if idx == -1:
            raise ValueError("invalid data")
        self.setCurrentIndex(idx)

    def text(self) -> str:
        return self.currentText()

    def hide_completer(self):
        """Hides the completion widget."""
        completer = widgets.Completer(self)
        self.setCompleter(completer)

value_changed = core.Signal(object) class-attribute

__init__(*args, **kwargs)

Source code in prettyqt\widgets\combobox.py

def __init__(self, *args, **kwargs):
    super().__init__(*args, **kwargs)
    self.currentIndexChanged.connect(self.index_changed)

__len__() -> int

Source code in prettyqt\widgets\combobox.py

def __len__(self) -> int:
    return self.count()

add(label: str, data = NoData, icon: datatypes.IconType = None)

Source code in prettyqt\widgets\combobox.py

def add(self, label: str, data=NoData, icon: datatypes.IconType = None):
    if data is NoData:
        data = label
    if icon is not None:
        icon = iconprovider.get_icon(icon)
        self.addItem(gui.Icon(icon), label, userData=data)
    else:
        self.addItem(label, userData=data)

add_items(items: Iterable | Mapping, default = NoData)

Source code in prettyqt\widgets\combobox.py

def add_items(self, items: Iterable | Mapping, default=NoData):
    if isinstance(items, Mapping):
        for k, v in items.items():
            self.addItem(v, userData=k)
    else:
        for i in items:
            if isinstance(i, tuple | list):
                self.add(*i)
            else:
                self.addItem(i, i)
    if default is not NoData:
        self.set_value(default)

get_icon_size() -> core.Size

Source code in prettyqt\widgets\combobox.py

def get_icon_size(self) -> core.Size:
    return core.Size(self.iconSize())

get_insert_policy() -> InsertPolicyStr

Return insert policy.

Returns:

Type	Description
InsertPolicyStr	insert policy

Source code in prettyqt\widgets\combobox.py

def get_insert_policy(self) -> InsertPolicyStr:
    """Return insert policy.

    Returns:
        insert policy
    """
    return INSERT_POLICY.inverse[self.insertPolicy()]

get_size_adjust_policy() -> SizeAdjustPolicyStr

Return size adjust policy.

Returns:

Type	Description
SizeAdjustPolicyStr	size adjust policy

Source code in prettyqt\widgets\combobox.py

def get_size_adjust_policy(self) -> SizeAdjustPolicyStr:
    """Return size adjust policy.

    Returns:
        size adjust policy
    """
    return SIZE_ADJUST_POLICY.inverse[self.sizeAdjustPolicy()]

get_value() -> Any

Source code in prettyqt\widgets\combobox.py

def get_value(self) -> Any:
    # if all(self.itemData(i) is None for i in range(self.count())):
    #     return self.currentText()
    # else:
    #     return self.currentData()
    return self.currentData()

hide_completer()

Hides the completion widget.

Source code in prettyqt\widgets\combobox.py

def hide_completer(self):
    """Hides the completion widget."""
    completer = widgets.Completer(self)
    self.setCompleter(completer)

index_changed(index: int)

Source code in prettyqt\widgets\combobox.py

def index_changed(self, index: int):
    data = self.itemData(index)
    self.value_changed.emit(data)

item_icon(index: int) -> gui.Icon | None

Source code in prettyqt\widgets\combobox.py

def item_icon(self, index: int) -> gui.Icon | None:
    icon = self.itemIcon(index)
    return None if icon.isNull() else gui.Icon(icon)

set_data(data: Any)

Source code in prettyqt\widgets\combobox.py

def set_data(self, data: Any):
    idx = self.findData(data)
    if idx == -1:
        raise ValueError("invalid data")
    self.setCurrentIndex(idx)

set_editable(editable: bool)

Source code in prettyqt\widgets\combobox.py

def set_editable(self, editable: bool):
    self.setEditable(editable)
    if self.completer() is None and editable:
        self.setCompleter(widgets.Completer(self))

set_icon_size(size: int | datatypes.SizeType)

Set size of the icons.

Source code in prettyqt\widgets\combobox.py

def set_icon_size(self, size: int | datatypes.SizeType):
    """Set size of the icons."""
    if isinstance(size, int):
        size = core.Size(size, size)
    elif isinstance(size, tuple):
        size = core.Size(*size)
    self.setIconSize(size)

set_insert_policy(policy: InsertPolicyStr)

Set insert policy.

Parameters:

Name	Type	Description	Default
policy	InsertPolicyStr	insert policy to use	required

Raises:

Type	Description
InvalidParamError	invalid insert policy

Source code in prettyqt\widgets\combobox.py

def set_insert_policy(self, policy: InsertPolicyStr):
    """Set insert policy.

    Args:
        policy: insert policy to use

    Raises:
        InvalidParamError: invalid insert policy
    """
    if policy not in INSERT_POLICY:
        raise InvalidParamError(policy, INSERT_POLICY)
    self.setInsertPolicy(INSERT_POLICY[policy])

set_min_char_length(chars: int)

Source code in prettyqt\widgets\combobox.py

def set_min_char_length(self, chars: int):
    self.setMinimumContentsLength(chars)

set_size_adjust_policy(policy: SizeAdjustPolicyStr)

Set size adjust policy.

Parameters:

Name	Type	Description	Default
policy	SizeAdjustPolicyStr	size adjust policy to use	required

Raises:

Type	Description
InvalidParamError	invalid size adjust policy

Source code in prettyqt\widgets\combobox.py

def set_size_adjust_policy(self, policy: SizeAdjustPolicyStr):
    """Set size adjust policy.

    Args:
        policy: size adjust policy to use

    Raises:
        InvalidParamError: invalid size adjust policy
    """
    if policy not in SIZE_ADJUST_POLICY:
        raise InvalidParamError(policy, SIZE_ADJUST_POLICY)
    self.setSizeAdjustPolicy(SIZE_ADJUST_POLICY[policy])

set_text(text: str)

Source code in prettyqt\widgets\combobox.py

def set_text(self, text: str):
    self.setCurrentText(text)

set_value(value: Any)

Source code in prettyqt\widgets\combobox.py

def set_value(self, value: Any):
    self.set_data(value)

text() -> str

Source code in prettyqt\widgets\combobox.py

def text(self) -> str:
    return self.currentText()

CommandLinkButton

Bases: widgets.PushButtonMixin, QtWidgets.QCommandLinkButton

Source code in prettyqt\widgets\commandlinkbutton.py

class CommandLinkButton(widgets.PushButtonMixin, QtWidgets.QCommandLinkButton):
    value_changed = core.Signal(bool)

value_changed = core.Signal(bool) class-attribute

CommonStyle

Bases: CommonStyleMixin, QtWidgets.QCommonStyle

Source code in prettyqt\widgets\commonstyle.py

class CommonStyle(CommonStyleMixin, QtWidgets.QCommonStyle):
    pass

CommonStyleMixin

Bases: widgets.StyleMixin

Source code in prettyqt\widgets\commonstyle.py

class CommonStyleMixin(widgets.StyleMixin):
    pass

Completer

Bases: core.ObjectMixin, QtWidgets.QCompleter

Source code in prettyqt\widgets\completer.py

class Completer(core.ObjectMixin, QtWidgets.QCompleter):
    def __init__(self, parent: QtWidgets.QWidget | None = None):
        super().__init__(parent)

    def set_sort_mode(self, mode: SortModeStr | None):
        """Set sort mode to use.

        Args:
            mode: sort mode to use

        Raises:
            InvalidParamError: sort mode does not exist
        """
        if mode is None:
            mode = "unsorted"
        if mode not in SORT_MODE:
            raise InvalidParamError(mode, SORT_MODE)
        self.setModelSorting(SORT_MODE[mode])

    def get_sort_mode(self) -> SortModeStr:
        """Return current sort mode.

        Returns:
            sort mode
        """
        return SORT_MODE.inverse[self.modelSorting()]

    def set_completion_mode(self, mode: CompletionModeStr):
        """Set completion mode to use.

        Args:
            mode: completion mode to use

        Raises:
            InvalidParamError: completion mode does not exist
        """
        if mode not in COMPLETION_MODE:
            raise InvalidParamError(mode, COMPLETION_MODE)
        self.setCompletionMode(COMPLETION_MODE[mode])

    def get_completion_mode(self) -> CompletionModeStr:
        """Return current completion mode.

        Returns:
            completion mode
        """
        return COMPLETION_MODE.inverse[self.completionMode()]

    def set_filter_mode(self, mode: constants.FilterModeStr):
        """Set filter mode to use.

        Args:
            mode: filter mode to use

        Raises:
            InvalidParamError: filter mode does not exist
        """
        if mode not in constants.FILTER_MODES:
            raise InvalidParamError(mode, constants.FILTER_MODES)
        self.setFilterMode(constants.FILTER_MODES[mode])

    def get_filter_mode(self) -> constants.FilterModeStr:
        """Return current filter mode.

        Returns:
            filter mode
        """
        return constants.FILTER_MODES.inverse[self.filterMode()]

    def set_case_sensitive(self, state: bool):
        """Set case sensitivity.

        Args:
            state: case sensitive

        """
        sensitivity = (
            QtCore.Qt.CaseSensitivity.CaseSensitive
            if state
            else QtCore.Qt.CaseSensitivity.CaseInsensitive
        )
        self.setCaseSensitivity(sensitivity)

    def is_case_sensitive(self) -> bool:
        """Return case sensitivity.

        Returns:
            case sensitivity
        """
        return bool(self.caseSensitivity())

__init__(parent: QtWidgets.QWidget | None = None)

Source code in prettyqt\widgets\completer.py

def __init__(self, parent: QtWidgets.QWidget | None = None):
    super().__init__(parent)

get_completion_mode() -> CompletionModeStr

Return current completion mode.

Returns:

Type	Description
CompletionModeStr	completion mode

Source code in prettyqt\widgets\completer.py

def get_completion_mode(self) -> CompletionModeStr:
    """Return current completion mode.

    Returns:
        completion mode
    """
    return COMPLETION_MODE.inverse[self.completionMode()]

get_filter_mode() -> constants.FilterModeStr

Return current filter mode.

Returns:

Type	Description
constants.FilterModeStr	filter mode

Source code in prettyqt\widgets\completer.py

def get_filter_mode(self) -> constants.FilterModeStr:
    """Return current filter mode.

    Returns:
        filter mode
    """
    return constants.FILTER_MODES.inverse[self.filterMode()]

get_sort_mode() -> SortModeStr

Return current sort mode.

Returns:

Type	Description
SortModeStr	sort mode

Source code in prettyqt\widgets\completer.py

def get_sort_mode(self) -> SortModeStr:
    """Return current sort mode.

    Returns:
        sort mode
    """
    return SORT_MODE.inverse[self.modelSorting()]

is_case_sensitive() -> bool

Return case sensitivity.

Returns:

Type	Description
bool	case sensitivity

Source code in prettyqt\widgets\completer.py

def is_case_sensitive(self) -> bool:
    """Return case sensitivity.

    Returns:
        case sensitivity
    """
    return bool(self.caseSensitivity())

set_case_sensitive(state: bool)

Set case sensitivity.

Parameters:

Name	Type	Description	Default
state	bool	case sensitive	required

Source code in prettyqt\widgets\completer.py

def set_case_sensitive(self, state: bool):
    """Set case sensitivity.

    Args:
        state: case sensitive

    """
    sensitivity = (
        QtCore.Qt.CaseSensitivity.CaseSensitive
        if state
        else QtCore.Qt.CaseSensitivity.CaseInsensitive
    )
    self.setCaseSensitivity(sensitivity)

set_completion_mode(mode: CompletionModeStr)

Set completion mode to use.

Parameters:

Name	Type	Description	Default
mode	CompletionModeStr	completion mode to use	required

Raises:

Type	Description
InvalidParamError	completion mode does not exist

Source code in prettyqt\widgets\completer.py

def set_completion_mode(self, mode: CompletionModeStr):
    """Set completion mode to use.

    Args:
        mode: completion mode to use

    Raises:
        InvalidParamError: completion mode does not exist
    """
    if mode not in COMPLETION_MODE:
        raise InvalidParamError(mode, COMPLETION_MODE)
    self.setCompletionMode(COMPLETION_MODE[mode])

set_filter_mode(mode: constants.FilterModeStr)

Set filter mode to use.

Parameters:

Name	Type	Description	Default
mode	constants.FilterModeStr	filter mode to use	required

Raises:

Type	Description
InvalidParamError	filter mode does not exist

Source code in prettyqt\widgets\completer.py

def set_filter_mode(self, mode: constants.FilterModeStr):
    """Set filter mode to use.

    Args:
        mode: filter mode to use

    Raises:
        InvalidParamError: filter mode does not exist
    """
    if mode not in constants.FILTER_MODES:
        raise InvalidParamError(mode, constants.FILTER_MODES)
    self.setFilterMode(constants.FILTER_MODES[mode])

set_sort_mode(mode: SortModeStr | None)

Set sort mode to use.

Parameters:

Name	Type	Description	Default
mode	SortModeStr | None	sort mode to use	required

Raises:

Type	Description
InvalidParamError	sort mode does not exist

Source code in prettyqt\widgets\completer.py

def set_sort_mode(self, mode: SortModeStr | None):
    """Set sort mode to use.

    Args:
        mode: sort mode to use

    Raises:
        InvalidParamError: sort mode does not exist
    """
    if mode is None:
        mode = "unsorted"
    if mode not in SORT_MODE:
        raise InvalidParamError(mode, SORT_MODE)
    self.setModelSorting(SORT_MODE[mode])

DataWidgetMapper

Bases: core.ObjectMixin, QtWidgets.QDataWidgetMapper

Source code in prettyqt\widgets\datawidgetmapper.py

class DataWidgetMapper(core.ObjectMixin, QtWidgets.QDataWidgetMapper):
    def set_orientation(self, orientation: constants.OrientationStr):
        """Set the orientation of the data widget mapper.

        Args:
            orientation: orientation for the data widget mapper

        Raises:
            InvalidParamError: orientation does not exist
        """
        if orientation not in constants.ORIENTATION:
            raise InvalidParamError(orientation, constants.ORIENTATION)
        self.setOrientation(constants.ORIENTATION[orientation])

    def get_orientation(self) -> constants.OrientationStr:
        """Return current orientation.

        Returns:
            orientation
        """
        return constants.ORIENTATION.inverse[self.orientation()]

    def set_submit_policy(self, policy: SubmitPolicyStr):
        """Set the submit policy of the mapper.

        Args:
            policy: submit_policy for the data widget mapper

        Raises:
            InvalidParamError: submit_policy does not exist
        """
        if policy not in SUBMIT_POLICY:
            raise InvalidParamError(policy, SUBMIT_POLICY)
        self.setSubmitPolicy(SUBMIT_POLICY[policy])

    def get_submit_policy(self) -> SubmitPolicyStr:
        """Return current submit policy.

        Returns:
            submit policy
        """
        return SUBMIT_POLICY.inverse[self.submitPolicy()]

    def add_mapping(
        self, widget: QtWidgets.QWidget, section: int, property_name: str | None = None
    ):
        if property_name is None:
            self.addMapping(widget, section)
        else:
            ba = QtCore.QByteArray(property_name.encode())
            self.addMapping(widget, section, ba)

    def get_mapped_property_name(self, widget: QtWidgets.QWidget) -> str:
        return self.mappedPropertyName(widget).data().decode()

add_mapping(widget: QtWidgets.QWidget, section: int, property_name: str | None = None)

Source code in prettyqt\widgets\datawidgetmapper.py

def add_mapping(
    self, widget: QtWidgets.QWidget, section: int, property_name: str | None = None
):
    if property_name is None:
        self.addMapping(widget, section)
    else:
        ba = QtCore.QByteArray(property_name.encode())
        self.addMapping(widget, section, ba)

get_mapped_property_name(widget: QtWidgets.QWidget) -> str

Source code in prettyqt\widgets\datawidgetmapper.py

def get_mapped_property_name(self, widget: QtWidgets.QWidget) -> str:
    return self.mappedPropertyName(widget).data().decode()

get_orientation() -> constants.OrientationStr

Return current orientation.

Returns:

Type	Description
constants.OrientationStr	orientation

Source code in prettyqt\widgets\datawidgetmapper.py

def get_orientation(self) -> constants.OrientationStr:
    """Return current orientation.

    Returns:
        orientation
    """
    return constants.ORIENTATION.inverse[self.orientation()]

get_submit_policy() -> SubmitPolicyStr

Return current submit policy.

Returns:

Type	Description
SubmitPolicyStr	submit policy

Source code in prettyqt\widgets\datawidgetmapper.py

def get_submit_policy(self) -> SubmitPolicyStr:
    """Return current submit policy.

    Returns:
        submit policy
    """
    return SUBMIT_POLICY.inverse[self.submitPolicy()]

set_orientation(orientation: constants.OrientationStr)

Set the orientation of the data widget mapper.

Parameters:

Name	Type	Description	Default
orientation	constants.OrientationStr	orientation for the data widget mapper	required

Raises:

Type	Description
InvalidParamError	orientation does not exist

Source code in prettyqt\widgets\datawidgetmapper.py

def set_orientation(self, orientation: constants.OrientationStr):
    """Set the orientation of the data widget mapper.

    Args:
        orientation: orientation for the data widget mapper

    Raises:
        InvalidParamError: orientation does not exist
    """
    if orientation not in constants.ORIENTATION:
        raise InvalidParamError(orientation, constants.ORIENTATION)
    self.setOrientation(constants.ORIENTATION[orientation])

set_submit_policy(policy: SubmitPolicyStr)

Set the submit policy of the mapper.

Parameters:

Name	Type	Description	Default
policy	SubmitPolicyStr	submit_policy for the data widget mapper	required

Raises:

Type	Description
InvalidParamError	submit_policy does not exist

Source code in prettyqt\widgets\datawidgetmapper.py

def set_submit_policy(self, policy: SubmitPolicyStr):
    """Set the submit policy of the mapper.

    Args:
        policy: submit_policy for the data widget mapper

    Raises:
        InvalidParamError: submit_policy does not exist
    """
    if policy not in SUBMIT_POLICY:
        raise InvalidParamError(policy, SUBMIT_POLICY)
    self.setSubmitPolicy(SUBMIT_POLICY[policy])

DateEdit

Bases: widgets.DateTimeEditMixin, QtWidgets.QDateEdit

Source code in prettyqt\widgets\dateedit.py

class DateEdit(widgets.DateTimeEditMixin, QtWidgets.QDateEdit):
    value_changed = core.Signal(datetime.datetime)

    def set_value(self, value: datatypes.DateType):
        if isinstance(value, str):
            value = QtCore.QDate.fromString(value)
        self.setDate(value)  # type: ignore

    def set_range(self, lower: datatypes.DateType, upper: datatypes.DateType):
        if isinstance(lower, str):
            lower = QtCore.QDate.fromString(lower)
        if isinstance(upper, str):
            upper = QtCore.QDate.fromString(upper)
        self.setToolTip(f"{lower} <= x <= {upper}")
        self.setDateRange(lower, upper)  # type: ignore

    def get_value(self) -> datetime.date:
        return self.get_date()

value_changed = core.Signal(datetime.datetime) class-attribute

get_value() -> datetime.date

Source code in prettyqt\widgets\dateedit.py

def get_value(self) -> datetime.date:
    return self.get_date()

set_range(lower: datatypes.DateType, upper: datatypes.DateType)

Source code in prettyqt\widgets\dateedit.py

def set_range(self, lower: datatypes.DateType, upper: datatypes.DateType):
    if isinstance(lower, str):
        lower = QtCore.QDate.fromString(lower)
    if isinstance(upper, str):
        upper = QtCore.QDate.fromString(upper)
    self.setToolTip(f"{lower} <= x <= {upper}")
    self.setDateRange(lower, upper)  # type: ignore

set_value(value: datatypes.DateType)

Source code in prettyqt\widgets\dateedit.py

def set_value(self, value: datatypes.DateType):
    if isinstance(value, str):
        value = QtCore.QDate.fromString(value)
    self.setDate(value)  # type: ignore

DateTimeEdit

Bases: DateTimeEditMixin, QtWidgets.QDateTimeEdit

Source code in prettyqt\widgets\datetimeedit.py

class DateTimeEdit(DateTimeEditMixin, QtWidgets.QDateTimeEdit):
    pass

DateTimeEditMixin

Bases: widgets.AbstractSpinBoxMixin

Source code in prettyqt\widgets\datetimeedit.py

class DateTimeEditMixin(widgets.AbstractSpinBoxMixin):
    value_changed = core.Signal(datetime.datetime)

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.setCalendarPopup(True)
        self.dateTimeChanged.connect(self.datetime_changed)

    def datetime_changed(self, date):
        dt = self.get_datetime()
        self.value_changed.emit(dt)

    def get_section_text(self, section: SectionsStr) -> str:
        if section not in SECTIONS:
            raise InvalidParamError(section, SECTIONS)
        return self.sectionText(SECTIONS[section])

    def get_current_section(self) -> SectionsStr:
        return SECTIONS.inverse[self.currentSection()]

    def set_current_section(self, section: SectionsStr):
        if section not in SECTIONS:
            raise InvalidParamError(section, SECTIONS)
        self.setCurrentSection(SECTIONS[section])

    def get_displayed_sections(self) -> list[SectionsStr]:
        return SECTIONS.get_list(self.displayedSections())

    def set_range(
        self,
        lower: datatypes.DateTimeType,
        upper: datatypes.DateTimeType,
    ):
        if isinstance(lower, str):
            lower = dateutil.parser.parse(lower)
        if isinstance(upper, str):
            upper = dateutil.parser.parse(upper)
        self.setToolTip(f"{lower} <= x <= {upper}")
        self.setDateTimeRange(lower, upper)  # type: ignore

    def set_format(self, fmt: str):
        self.setDisplayFormat(fmt)

    def get_value(self) -> datetime.datetime:
        return self.get_datetime()

    def set_value(self, value: datetime.datetime):
        self.setDateTime(value)  # type: ignore

    def get_datetime(self) -> datetime.datetime:
        return self.dateTime().toPython()  # type: ignore

    def min_datetime(self) -> datetime.datetime:
        return self.minimumDateTime().toPython()  # type: ignore

    def max_datetime(self) -> datetime.datetime:
        return self.maximumDateTime().toPython()  # type: ignore

    def min_date(self) -> datetime.date:
        return self.minimumDate().toPython()  # type: ignore

    def max_date(self) -> datetime.date:
        return self.maximumDate().toPython()  # type: ignore

    def get_date(self) -> datetime.date:
        return self.date().toPython()  # type: ignore

    def min_time(self) -> datetime.time:
        return self.minimumTime().toPython()  # type: ignore

    def max_time(self) -> datetime.time:
        return self.maximumTime().toPython()  # type: ignore

    def get_time(self) -> datetime.time:
        return self.time().toPython()  # type: ignore

value_changed = core.Signal(datetime.datetime) class-attribute

__init__(*args, **kwargs)

Source code in prettyqt\widgets\datetimeedit.py

def __init__(self, *args, **kwargs):
    super().__init__(*args, **kwargs)
    self.setCalendarPopup(True)
    self.dateTimeChanged.connect(self.datetime_changed)

datetime_changed(date)

Source code in prettyqt\widgets\datetimeedit.py

def datetime_changed(self, date):
    dt = self.get_datetime()
    self.value_changed.emit(dt)

get_current_section() -> SectionsStr

Source code in prettyqt\widgets\datetimeedit.py

def get_current_section(self) -> SectionsStr:
    return SECTIONS.inverse[self.currentSection()]

get_date() -> datetime.date

Source code in prettyqt\widgets\datetimeedit.py

def get_date(self) -> datetime.date:
    return self.date().toPython()  # type: ignore

get_datetime() -> datetime.datetime

Source code in prettyqt\widgets\datetimeedit.py

def get_datetime(self) -> datetime.datetime:
    return self.dateTime().toPython()  # type: ignore

get_displayed_sections() -> list[SectionsStr]

Source code in prettyqt\widgets\datetimeedit.py

def get_displayed_sections(self) -> list[SectionsStr]:
    return SECTIONS.get_list(self.displayedSections())

get_section_text(section: SectionsStr) -> str

Source code in prettyqt\widgets\datetimeedit.py

def get_section_text(self, section: SectionsStr) -> str:
    if section not in SECTIONS:
        raise InvalidParamError(section, SECTIONS)
    return self.sectionText(SECTIONS[section])

get_time() -> datetime.time

Source code in prettyqt\widgets\datetimeedit.py

def get_time(self) -> datetime.time:
    return self.time().toPython()  # type: ignore

get_value() -> datetime.datetime

Source code in prettyqt\widgets\datetimeedit.py

def get_value(self) -> datetime.datetime:
    return self.get_datetime()

max_date() -> datetime.date

Source code in prettyqt\widgets\datetimeedit.py

def max_date(self) -> datetime.date:
    return self.maximumDate().toPython()  # type: ignore

max_datetime() -> datetime.datetime

Source code in prettyqt\widgets\datetimeedit.py

def max_datetime(self) -> datetime.datetime:
    return self.maximumDateTime().toPython()  # type: ignore

max_time() -> datetime.time

Source code in prettyqt\widgets\datetimeedit.py

def max_time(self) -> datetime.time:
    return self.maximumTime().toPython()  # type: ignore

min_date() -> datetime.date

Source code in prettyqt\widgets\datetimeedit.py

def min_date(self) -> datetime.date:
    return self.minimumDate().toPython()  # type: ignore

min_datetime() -> datetime.datetime

Source code in prettyqt\widgets\datetimeedit.py

def min_datetime(self) -> datetime.datetime:
    return self.minimumDateTime().toPython()  # type: ignore

min_time() -> datetime.time

Source code in prettyqt\widgets\datetimeedit.py

def min_time(self) -> datetime.time:
    return self.minimumTime().toPython()  # type: ignore

set_current_section(section: SectionsStr)

Source code in prettyqt\widgets\datetimeedit.py

def set_current_section(self, section: SectionsStr):
    if section not in SECTIONS:
        raise InvalidParamError(section, SECTIONS)
    self.setCurrentSection(SECTIONS[section])

set_format(fmt: str)

Source code in prettyqt\widgets\datetimeedit.py

def set_format(self, fmt: str):
    self.setDisplayFormat(fmt)

set_range(lower: datatypes.DateTimeType, upper: datatypes.DateTimeType)

Source code in prettyqt\widgets\datetimeedit.py

def set_range(
    self,
    lower: datatypes.DateTimeType,
    upper: datatypes.DateTimeType,
):
    if isinstance(lower, str):
        lower = dateutil.parser.parse(lower)
    if isinstance(upper, str):
        upper = dateutil.parser.parse(upper)
    self.setToolTip(f"{lower} <= x <= {upper}")
    self.setDateTimeRange(lower, upper)  # type: ignore

set_value(value: datetime.datetime)

Source code in prettyqt\widgets\datetimeedit.py

def set_value(self, value: datetime.datetime):
    self.setDateTime(value)  # type: ignore

Dial

Bases: widgets.AbstractSliderMixin, QtWidgets.QDial

Source code in prettyqt\widgets\dial.py

class Dial(widgets.AbstractSliderMixin, QtWidgets.QDial):
    value_changed = core.Signal(int)

    def __init__(self, parent: QtWidgets.QWidget | None = None):
        super().__init__(parent)
        self.valueChanged.connect(self.on_value_change)

value_changed = core.Signal(int) class-attribute

__init__(parent: QtWidgets.QWidget | None = None)

Source code in prettyqt\widgets\dial.py

def __init__(self, parent: QtWidgets.QWidget | None = None):
    super().__init__(parent)
    self.valueChanged.connect(self.on_value_change)

Dialog

Bases: DialogMixin, QtWidgets.QDialog

Source code in prettyqt\widgets\dialog.py

class Dialog(DialogMixin, QtWidgets.QDialog):
    pass

DialogButtonBox

Bases: widgets.WidgetMixin, QtWidgets.QDialogButtonBox

Source code in prettyqt\widgets\dialogbuttonbox.py

class DialogButtonBox(widgets.WidgetMixin, QtWidgets.QDialogButtonBox):
    button_clicked = core.Signal(str)

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.clicked.connect(self.on_click)

    def __len__(self) -> int:
        return len(self.buttons())

    def __getitem__(self, index: ButtonStr) -> QtWidgets.QPushButton:
        return self.button(BUTTONS[index])

    def __iter__(self) -> Iterator[QtWidgets.QAbstractButton]:
        return iter(self.buttons())

    def __contains__(self, index: ButtonStr):
        return self.button(BUTTONS[index]) is not None

    @classmethod
    def create(cls, **kwargs):
        box = cls()
        for k, v in kwargs.items():
            box.add_default_button(k, callback=v)  # type: ignore
        return box

    def on_click(self, button: QtCore.QObject):
        self.button_clicked.emit(button.objectName())

    def set_horizontal(self):
        self.setOrientation(constants.HORIZONTAL)

    def set_vertical(self):
        self.setOrientation(constants.VERTICAL)

    def set_orientation(self, orientation: constants.OrientationStr):
        """Set the orientation of the button box.

        Args:
            orientation: orientation for the button box

        Raises:
            InvalidParamError: orientation does not exist
        """
        if orientation not in constants.ORIENTATION:
            raise InvalidParamError(orientation, constants.ORIENTATION)
        self.setOrientation(constants.ORIENTATION[orientation])

    def get_orientation(self) -> constants.OrientationStr:
        """Return current orientation.

        Returns:
            orientation
        """
        return constants.ORIENTATION.inverse[self.orientation()]

    def add_default_buttons(self, buttons: Sequence[ButtonStr]):
        return [self.add_default_button(btn) for btn in buttons]

    def add_default_button(
        self, button: ButtonStr, callback: Callable | None = None
    ) -> QtWidgets.QPushButton:
        """Add a default button.

        Args:
            button: button to add
            callback: function to call when button gets clicked

        Returns:
            created button

        Raises:
            InvalidParamError: Button type not available
        """
        if button not in BUTTONS:
            raise InvalidParamError(button, BUTTONS)
        btn = self.addButton(BUTTONS[button])
        btn.setObjectName(button)
        if callback:
            btn.clicked.connect(callback)
        return btn

    def add_button(
        self,
        button: QtWidgets.QPushButton | ButtonStr,
        role: RoleStr = "accept",
        callback: Callable | None = None,
    ) -> widgets.PushButton:
        """Add a button.

        Args:
            button: button to add
            role: role of the button
            callback: function to call when button gets clicked

        Returns:
            created button

        Raises:
            InvalidParamError: Button type not available
        """
        if isinstance(button, str):
            button = widgets.PushButton(button)
        self.addButton(button, ROLES[role])
        if callback:
            button.clicked.connect(callback)
        return button

button_clicked = core.Signal(str) class-attribute

__contains__(index: ButtonStr)

Source code in prettyqt\widgets\dialogbuttonbox.py

def __contains__(self, index: ButtonStr):
    return self.button(BUTTONS[index]) is not None

__getitem__(index: ButtonStr) -> QtWidgets.QPushButton

Source code in prettyqt\widgets\dialogbuttonbox.py

def __getitem__(self, index: ButtonStr) -> QtWidgets.QPushButton:
    return self.button(BUTTONS[index])

__init__(*args, **kwargs)

Source code in prettyqt\widgets\dialogbuttonbox.py

def __init__(self, *args, **kwargs):
    super().__init__(*args, **kwargs)
    self.clicked.connect(self.on_click)

__iter__() -> Iterator[QtWidgets.QAbstractButton]

Source code in prettyqt\widgets\dialogbuttonbox.py

def __iter__(self) -> Iterator[QtWidgets.QAbstractButton]:
    return iter(self.buttons())

__len__() -> int

Source code in prettyqt\widgets\dialogbuttonbox.py

def __len__(self) -> int:
    return len(self.buttons())

add_button(button: QtWidgets.QPushButton | ButtonStr, role: RoleStr = 'accept', callback: Callable | None = None) -> widgets.PushButton

Add a button.

Parameters:

Name	Type	Description	Default
button	QtWidgets.QPushButton | ButtonStr	button to add	required
role	RoleStr	role of the button	'accept'
callback	Callable | None	function to call when button gets clicked	None

Returns:

Type	Description
widgets.PushButton	created button

Raises:

Type	Description
InvalidParamError	Button type not available

Source code in prettyqt\widgets\dialogbuttonbox.py

def add_button(
    self,
    button: QtWidgets.QPushButton | ButtonStr,
    role: RoleStr = "accept",
    callback: Callable | None = None,
) -> widgets.PushButton:
    """Add a button.

    Args:
        button: button to add
        role: role of the button
        callback: function to call when button gets clicked

    Returns:
        created button

    Raises:
        InvalidParamError: Button type not available
    """
    if isinstance(button, str):
        button = widgets.PushButton(button)
    self.addButton(button, ROLES[role])
    if callback:
        button.clicked.connect(callback)
    return button

add_default_button(button: ButtonStr, callback: Callable | None = None) -> QtWidgets.QPushButton

Add a default button.

Parameters:

Name	Type	Description	Default
button	ButtonStr	button to add	required
callback	Callable | None	function to call when button gets clicked	None

Returns:

Type	Description
QtWidgets.QPushButton	created button

Raises:

Type	Description
InvalidParamError	Button type not available

Source code in prettyqt\widgets\dialogbuttonbox.py

def add_default_button(
    self, button: ButtonStr, callback: Callable | None = None
) -> QtWidgets.QPushButton:
    """Add a default button.

    Args:
        button: button to add
        callback: function to call when button gets clicked

    Returns:
        created button

    Raises:
        InvalidParamError: Button type not available
    """
    if button not in BUTTONS:
        raise InvalidParamError(button, BUTTONS)
    btn = self.addButton(BUTTONS[button])
    btn.setObjectName(button)
    if callback:
        btn.clicked.connect(callback)
    return btn

add_default_buttons(buttons: Sequence[ButtonStr])

Source code in prettyqt\widgets\dialogbuttonbox.py

def add_default_buttons(self, buttons: Sequence[ButtonStr]):
    return [self.add_default_button(btn) for btn in buttons]

create(**kwargs) classmethod

Source code in prettyqt\widgets\dialogbuttonbox.py

@classmethod
def create(cls, **kwargs):
    box = cls()
    for k, v in kwargs.items():
        box.add_default_button(k, callback=v)  # type: ignore
    return box

get_orientation() -> constants.OrientationStr

Return current orientation.

Returns:

Type	Description
constants.OrientationStr	orientation

Source code in prettyqt\widgets\dialogbuttonbox.py

def get_orientation(self) -> constants.OrientationStr:
    """Return current orientation.

    Returns:
        orientation
    """
    return constants.ORIENTATION.inverse[self.orientation()]

on_click(button: QtCore.QObject)

Source code in prettyqt\widgets\dialogbuttonbox.py

def on_click(self, button: QtCore.QObject):
    self.button_clicked.emit(button.objectName())

set_horizontal()

Source code in prettyqt\widgets\dialogbuttonbox.py

def set_horizontal(self):
    self.setOrientation(constants.HORIZONTAL)

set_orientation(orientation: constants.OrientationStr)

Set the orientation of the button box.

Parameters:

Name	Type	Description	Default
orientation	constants.OrientationStr	orientation for the button box	required

Raises:

Type	Description
InvalidParamError	orientation does not exist

Source code in prettyqt\widgets\dialogbuttonbox.py

def set_orientation(self, orientation: constants.OrientationStr):
    """Set the orientation of the button box.

    Args:
        orientation: orientation for the button box

    Raises:
        InvalidParamError: orientation does not exist
    """
    if orientation not in constants.ORIENTATION:
        raise InvalidParamError(orientation, constants.ORIENTATION)
    self.setOrientation(constants.ORIENTATION[orientation])

set_vertical()

Source code in prettyqt\widgets\dialogbuttonbox.py

def set_vertical(self):
    self.setOrientation(constants.VERTICAL)

DialogMixin

Bases: widgets.WidgetMixin

Source code in prettyqt\widgets\dialog.py

class DialogMixin(widgets.WidgetMixin):
    def __init__(
        self,
        title: str = "",
        icon: datatypes.IconType = None,
        parent: QtWidgets.QWidget | None = None,
        delete_on_close: bool = False,
        layout: None | str | QtWidgets.QLayout = None,
    ):
        super().__init__(parent=parent)
        self.set_title(title)
        self.set_icon(icon)
        if delete_on_close:
            self.delete_on_close()
        if layout is not None:
            self.set_layout(layout)

    def __getitem__(self, index: str) -> QtWidgets.QWidget:
        result = self.find_child(QtWidgets.QWidget, index)
        if result is None:
            raise KeyError("Widget not found")
        return result

    def serialize_fields(self):
        return dict(
            # modal=self.isModal(),
            # layout=self.layout(),
            size_grip_enabled=self.isSizeGripEnabled(),
            size=(self.size().width(), self.size().height()),
        )

    def keyPressEvent(self, e):
        match e.key():
            case QtCore.Qt.Key.Key_Escape:
                self.close()
            case QtCore.Qt.Key.Key_F11 if self.isMaximized():
                self.showNormal()
            case QtCore.Qt.Key.Key_F11:
                self.showMaximized()
            case _:
                super().keyPressEvent(e)

    def delete_on_close(self):
        self.setAttribute(QtCore.Qt.WidgetAttribute.WA_DeleteOnClose)

    def add_widget(self, widget: QtWidgets.QWidget) -> QtWidgets.QWidget:
        self.box += widget
        return widget

    def add_buttonbox(self) -> widgets.DialogButtonBox:
        button_box = widgets.DialogButtonBox.create(ok=self.accept, cancel=self.reject)
        self.box.add(button_box)
        return button_box

    def show_blocking(self) -> bool:
        self.show()
        return bool(self.main_loop())

    def is_accepted(self) -> bool:
        return self.result() == QtWidgets.QDialog.DialogCode.Accepted

    def main_loop(self) -> int:
        return self.exec()

__getitem__(index: str) -> QtWidgets.QWidget

Source code in prettyqt\widgets\dialog.py

def __getitem__(self, index: str) -> QtWidgets.QWidget:
    result = self.find_child(QtWidgets.QWidget, index)
    if result is None:
        raise KeyError("Widget not found")
    return result

__init__(title: str = '', icon: datatypes.IconType = None, parent: QtWidgets.QWidget | None = None, delete_on_close: bool = False, layout: None | str | QtWidgets.QLayout = None)

Source code in prettyqt\widgets\dialog.py

def __init__(
    self,
    title: str = "",
    icon: datatypes.IconType = None,
    parent: QtWidgets.QWidget | None = None,
    delete_on_close: bool = False,
    layout: None | str | QtWidgets.QLayout = None,
):
    super().__init__(parent=parent)
    self.set_title(title)
    self.set_icon(icon)
    if delete_on_close:
        self.delete_on_close()
    if layout is not None:
        self.set_layout(layout)

add_buttonbox() -> widgets.DialogButtonBox

Source code in prettyqt\widgets\dialog.py

def add_buttonbox(self) -> widgets.DialogButtonBox:
    button_box = widgets.DialogButtonBox.create(ok=self.accept, cancel=self.reject)
    self.box.add(button_box)
    return button_box

add_widget(widget: QtWidgets.QWidget) -> QtWidgets.QWidget

Source code in prettyqt\widgets\dialog.py

def add_widget(self, widget: QtWidgets.QWidget) -> QtWidgets.QWidget:
    self.box += widget
    return widget

delete_on_close()

Source code in prettyqt\widgets\dialog.py

def delete_on_close(self):
    self.setAttribute(QtCore.Qt.WidgetAttribute.WA_DeleteOnClose)

is_accepted() -> bool

Source code in prettyqt\widgets\dialog.py

def is_accepted(self) -> bool:
    return self.result() == QtWidgets.QDialog.DialogCode.Accepted

keyPressEvent(e)

Source code in prettyqt\widgets\dialog.py

def keyPressEvent(self, e):
    match e.key():
        case QtCore.Qt.Key.Key_Escape:
            self.close()
        case QtCore.Qt.Key.Key_F11 if self.isMaximized():
            self.showNormal()
        case QtCore.Qt.Key.Key_F11:
            self.showMaximized()
        case _:
            super().keyPressEvent(e)

main_loop() -> int

Source code in prettyqt\widgets\dialog.py

def main_loop(self) -> int:
    return self.exec()

serialize_fields()

Source code in prettyqt\widgets\dialog.py

def serialize_fields(self):
    return dict(
        # modal=self.isModal(),
        # layout=self.layout(),
        size_grip_enabled=self.isSizeGripEnabled(),
        size=(self.size().width(), self.size().height()),
    )

show_blocking() -> bool

Source code in prettyqt\widgets\dialog.py

def show_blocking(self) -> bool:
    self.show()
    return bool(self.main_loop())

DockWidget

Bases: widgets.WidgetMixin, QtWidgets.QDockWidget

Customized DockWidget class.

Contains a custom TitleBar with maximize button

Source code in prettyqt\widgets\dockwidget.py

class DockWidget(widgets.WidgetMixin, QtWidgets.QDockWidget):
    """Customized DockWidget class.

    Contains a custom TitleBar with maximize button
    """

    def __init__(self, *args, **kwargs):
        name = kwargs.pop("name", None)
        title = kwargs.pop("title", None)
        super().__init__(*args, **kwargs)
        if name:
            self.set_id(name)
        if title:
            self.set_title(title)
        self.set_allowed_areas("all")

    # def __setstate__(self, state: dict[str, Any]) -> None:
    #     self.set_widget(state["widget"])

    # def __reduce__(self):
    #     return type(self), (), self.__getstate__()

    # def serialize_fields(self) -> dict[str, Any]:
    #     return dict(widget=self.widget())

    def set_widget(self, widget: QtWidgets.QWidget):
        self.setWidget(widget)

    def set_allowed_areas(self, area: constants.DockPositionsStr):
        self.setAllowedAreas(constants.DOCK_POSITIONS[area])

    def setup_title_bar(self):
        title_bar = widgets.Widget()
        layout = widgets.BoxLayout("horizontal")
        layout.set_margin(0)
        layout.set_alignment("right")
        title_bar.set_layout(layout)
        maximize_button = widgets.PushButton()
        layout.add(maximize_button)
        maximize_button.set_style_icon("titlebar_max_button")
        maximize_button.clicked.connect(self.maximize)
        close_button = widgets.PushButton()
        close_button.set_style_icon("titlebar_close_button")
        layout.add(close_button)
        close_button.clicked.connect(self.close)
        self.setTitleBarWidget(title_bar)

    @deprecated(reason="This method is deprecated, use 'maximize' instead.")
    def maximise(self):
        self.maximize()

    def maximize(self):
        if not self.isFloating():
            self.setFloating(True)
        if not self.isMaximized():
            self.showMaximized()
        else:
            self.showMinimized()

__init__(*args, **kwargs)

Source code in prettyqt\widgets\dockwidget.py

def __init__(self, *args, **kwargs):
    name = kwargs.pop("name", None)
    title = kwargs.pop("title", None)
    super().__init__(*args, **kwargs)
    if name:
        self.set_id(name)
    if title:
        self.set_title(title)
    self.set_allowed_areas("all")

maximise()

Source code in prettyqt\widgets\dockwidget.py

@deprecated(reason="This method is deprecated, use 'maximize' instead.")
def maximise(self):
    self.maximize()

maximize()

Source code in prettyqt\widgets\dockwidget.py

def maximize(self):
    if not self.isFloating():
        self.setFloating(True)
    if not self.isMaximized():
        self.showMaximized()
    else:
        self.showMinimized()

set_allowed_areas(area: constants.DockPositionsStr)

Source code in prettyqt\widgets\dockwidget.py

def set_allowed_areas(self, area: constants.DockPositionsStr):
    self.setAllowedAreas(constants.DOCK_POSITIONS[area])

set_widget(widget: QtWidgets.QWidget)

Source code in prettyqt\widgets\dockwidget.py

def set_widget(self, widget: QtWidgets.QWidget):
    self.setWidget(widget)

setup_title_bar()

Source code in prettyqt\widgets\dockwidget.py

def setup_title_bar(self):
    title_bar = widgets.Widget()
    layout = widgets.BoxLayout("horizontal")
    layout.set_margin(0)
    layout.set_alignment("right")
    title_bar.set_layout(layout)
    maximize_button = widgets.PushButton()
    layout.add(maximize_button)
    maximize_button.set_style_icon("titlebar_max_button")
    maximize_button.clicked.connect(self.maximize)
    close_button = widgets.PushButton()
    close_button.set_style_icon("titlebar_close_button")
    layout.add(close_button)
    close_button.clicked.connect(self.close)
    self.setTitleBarWidget(title_bar)

DoubleSpinBox

Bases: widgets.AbstractSpinBoxMixin, QtWidgets.QDoubleSpinBox

Source code in prettyqt\widgets\doublespinbox.py

class DoubleSpinBox(widgets.AbstractSpinBoxMixin, QtWidgets.QDoubleSpinBox):
    value_changed = core.Signal(float)

    def __init__(
        self,
        parent: QtWidgets.QWidget | None = None,
        min_value: float | None = None,
        max_value: float | None = None,
        default_value: float | None = None,
    ):
        super().__init__(parent)
        self.valueChanged.connect(self.value_changed)
        self.set_range(min_value, max_value)
        if default_value is not None:
            self.set_value(default_value)

    def set_range(self, start: float | None, end: float | None):
        if start is None:
            start = -float("inf")
        if end is None:
            end = float("inf")
        self.setRange(start, end)

value_changed = core.Signal(float) class-attribute

__init__(parent: QtWidgets.QWidget | None = None, min_value: float | None = None, max_value: float | None = None, default_value: float | None = None)

Source code in prettyqt\widgets\doublespinbox.py

def __init__(
    self,
    parent: QtWidgets.QWidget | None = None,
    min_value: float | None = None,
    max_value: float | None = None,
    default_value: float | None = None,
):
    super().__init__(parent)
    self.valueChanged.connect(self.value_changed)
    self.set_range(min_value, max_value)
    if default_value is not None:
        self.set_value(default_value)

set_range(start: float | None, end: float | None)

Source code in prettyqt\widgets\doublespinbox.py

def set_range(self, start: float | None, end: float | None):
    if start is None:
        start = -float("inf")
    if end is None:
        end = float("inf")
    self.setRange(start, end)

ErrorMessage

Bases: widgets.DialogMixin, QtWidgets.QErrorMessage

Source code in prettyqt\widgets\errormessage.py

class ErrorMessage(widgets.DialogMixin, QtWidgets.QErrorMessage):
    pass

FileDialog

Bases: widgets.DialogMixin, QtWidgets.QFileDialog

Simple dialog used to display some widget.

Source code in prettyqt\widgets\filedialog.py

class FileDialog(widgets.DialogMixin, QtWidgets.QFileDialog):
    """Simple dialog used to display some widget."""

    def __init__(
        self,
        path: None | datatypes.PathType = None,
        mode: AcceptModeStr = "open",
        caption: str | None = None,
        path_id: str | None = None,
        extension_filter: dict | None = None,
        file_mode: FileModeStr = "existing_files",
        parent: QtWidgets.QWidget | None = None,
    ):
        super().__init__(parent=parent)
        self.set_title(caption)
        self.path_id = path_id
        if extension_filter:
            self.set_extension_filter(extension_filter)
        if path_id is not None and path is None:
            settings = core.Settings()
            path = settings.get(path_id, "")
        if path is not None:
            self.set_directory(path)
        self.set_file_mode(file_mode)
        self.set_accept_mode(mode)

    def set_accept_mode(self, mode: AcceptModeStr):
        """Set accept mode.

        Args:
            mode: accept mode to use

        Raises:
            InvalidParamError: invalid accept mode
        """
        if mode not in ACCEPT_MODE:
            raise InvalidParamError(mode, ACCEPT_MODE)
        self.setAcceptMode(ACCEPT_MODE[mode])

    def get_accept_mode(self) -> AcceptModeStr:
        """Return accept mode.

        Returns:
            accept mode
        """
        return ACCEPT_MODE.inverse[self.acceptMode()]

    def set_view_mode(self, mode: ViewModeStr):
        """Set view mode.

        Args:
            mode: view mode to use

        Raises:
            InvalidParamError: invalid view mode
        """
        if mode not in VIEW_MODE:
            raise InvalidParamError(mode, VIEW_MODE)
        self.setViewMode(VIEW_MODE[mode])

    def get_view_mode(self) -> ViewModeStr:
        """Return view mode.

        Returns:
            view mode
        """
        return VIEW_MODE.inverse[self.viewMode()]

    def set_label_text(self, label: LabelStr, text: str):
        """Set the label text for button label.

        Args:
            label: button to set text for
            text: text to use
        """
        if label not in LABEL:
            raise InvalidParamError(label, LABEL)
        self.setLabelText(LABEL[label], text)

    def get_label_text(self, label: LabelStr) -> str:
        """Return label text.

        Returns:
            label text
        """
        return self.labelText(LABEL[label])

    def get_file_mode(self) -> FileModeStr:
        """Return file mode.

        Returns:
            file mode
        """
        return FILE_MODE.inverse[self.fileMode()]

    def set_file_mode(self, mode: FileModeStr):
        """Set the file mode of the dialog.

        Args:
            mode: mode to use
        """
        self.setFileMode(FILE_MODE[mode])

    def selected_files(self) -> list[pathlib.Path]:
        return [pathlib.Path(p) for p in self.selectedFiles()]

    def selected_file(self) -> pathlib.Path | None:
        selected = self.selectedFiles()
        return pathlib.Path(selected[0]) if selected else None

    def choose_folder(self) -> list[pathlib.Path] | None:
        self.set_file_mode("directory")
        return self.choose()

    def open_file(self) -> list[pathlib.Path] | None:
        self.set_file_mode("existing_file")
        return self.choose()

    def choose(self) -> list[pathlib.Path] | None:
        result = self.main_loop()
        if result != self.DialogCode.Accepted:
            return None
        paths = self.selected_files()
        if self.path_id:
            settings = core.Settings()
            folder_path = paths[0].parent
            settings.setValue(self.path_id, str(folder_path))
        return paths

    def set_extension_filter(self, extension_dict: dict[str, list[str]]):
        """Set filter based on given dictionary.

        dict must contain "'name': ['.ext1', '.ext2']" as key-value pairs

        Args:
            extension_dict: filter dictionary
        """
        items = [
            f"{k} ({' '.join(f'*{ext}' for ext in v)})" for k, v in extension_dict.items()
        ]
        filter_str = ";;".join(items)
        self.setNameFilter(filter_str)

    def get_directory(self) -> pathlib.Path:
        """Return current directory.

        returns current directory level as a Pathlib object

        Returns:
            Pathlib object
        """
        return pathlib.Path(self.directory().absolutePath())

    def set_directory(self, path: datatypes.PathType):
        """Set start directory."""
        path = os.fspath(path)
        self.setDirectory(path)

    def set_filter(self, *filters: core.dir.FilterStr):
        for item in filters:
            if item not in core.dir.FILTERS:
                raise InvalidParamError(item, core.dir.FILTERS)
        flags = helpers.merge_flags(filters, core.dir.FILTERS)
        self.setFilter(flags)

    def get_filter(self) -> list[core.dir.FilterStr]:
        return core.dir.FILTERS.get_list(self.filter())

path_id = path_id instance-attribute

__init__(path: None | datatypes.PathType = None, mode: AcceptModeStr = 'open', caption: str | None = None, path_id: str | None = None, extension_filter: dict | None = None, file_mode: FileModeStr = 'existing_files', parent: QtWidgets.QWidget | None = None)

Source code in prettyqt\widgets\filedialog.py

def __init__(
    self,
    path: None | datatypes.PathType = None,
    mode: AcceptModeStr = "open",
    caption: str | None = None,
    path_id: str | None = None,
    extension_filter: dict | None = None,
    file_mode: FileModeStr = "existing_files",
    parent: QtWidgets.QWidget | None = None,
):
    super().__init__(parent=parent)
    self.set_title(caption)
    self.path_id = path_id
    if extension_filter:
        self.set_extension_filter(extension_filter)
    if path_id is not None and path is None:
        settings = core.Settings()
        path = settings.get(path_id, "")
    if path is not None:
        self.set_directory(path)
    self.set_file_mode(file_mode)
    self.set_accept_mode(mode)

choose() -> list[pathlib.Path] | None

Source code in prettyqt\widgets\filedialog.py

def choose(self) -> list[pathlib.Path] | None:
    result = self.main_loop()
    if result != self.DialogCode.Accepted:
        return None
    paths = self.selected_files()
    if self.path_id:
        settings = core.Settings()
        folder_path = paths[0].parent
        settings.setValue(self.path_id, str(folder_path))
    return paths

choose_folder() -> list[pathlib.Path] | None

Source code in prettyqt\widgets\filedialog.py

def choose_folder(self) -> list[pathlib.Path] | None:
    self.set_file_mode("directory")
    return self.choose()

get_accept_mode() -> AcceptModeStr

Return accept mode.

Returns:

Type	Description
AcceptModeStr	accept mode

Source code in prettyqt\widgets\filedialog.py

def get_accept_mode(self) -> AcceptModeStr:
    """Return accept mode.

    Returns:
        accept mode
    """
    return ACCEPT_MODE.inverse[self.acceptMode()]

get_directory() -> pathlib.Path

Return current directory.

returns current directory level as a Pathlib object

Returns:

Type	Description
pathlib.Path	Pathlib object

Source code in prettyqt\widgets\filedialog.py

def get_directory(self) -> pathlib.Path:
    """Return current directory.

    returns current directory level as a Pathlib object

    Returns:
        Pathlib object
    """
    return pathlib.Path(self.directory().absolutePath())

get_file_mode() -> FileModeStr

Return file mode.

Returns:

Type	Description
FileModeStr	file mode

Source code in prettyqt\widgets\filedialog.py

def get_file_mode(self) -> FileModeStr:
    """Return file mode.

    Returns:
        file mode
    """
    return FILE_MODE.inverse[self.fileMode()]

get_filter() -> list[core.dir.FilterStr]

Source code in prettyqt\widgets\filedialog.py

def get_filter(self) -> list[core.dir.FilterStr]:
    return core.dir.FILTERS.get_list(self.filter())

get_label_text(label: LabelStr) -> str

Return label text.

Returns:

Type	Description
str	label text

Source code in prettyqt\widgets\filedialog.py

def get_label_text(self, label: LabelStr) -> str:
    """Return label text.

    Returns:
        label text
    """
    return self.labelText(LABEL[label])

get_view_mode() -> ViewModeStr

Return view mode.

Returns:

Type	Description
ViewModeStr	view mode

Source code in prettyqt\widgets\filedialog.py

def get_view_mode(self) -> ViewModeStr:
    """Return view mode.

    Returns:
        view mode
    """
    return VIEW_MODE.inverse[self.viewMode()]

open_file() -> list[pathlib.Path] | None

Source code in prettyqt\widgets\filedialog.py

def open_file(self) -> list[pathlib.Path] | None:
    self.set_file_mode("existing_file")
    return self.choose()

selected_file() -> pathlib.Path | None

Source code in prettyqt\widgets\filedialog.py

def selected_file(self) -> pathlib.Path | None:
    selected = self.selectedFiles()
    return pathlib.Path(selected[0]) if selected else None

selected_files() -> list[pathlib.Path]

Source code in prettyqt\widgets\filedialog.py

def selected_files(self) -> list[pathlib.Path]:
    return [pathlib.Path(p) for p in self.selectedFiles()]

set_accept_mode(mode: AcceptModeStr)

Set accept mode.

Parameters:

Name	Type	Description	Default
mode	AcceptModeStr	accept mode to use	required

Raises:

Type	Description
InvalidParamError	invalid accept mode

Source code in prettyqt\widgets\filedialog.py

def set_accept_mode(self, mode: AcceptModeStr):
    """Set accept mode.

    Args:
        mode: accept mode to use

    Raises:
        InvalidParamError: invalid accept mode
    """
    if mode not in ACCEPT_MODE:
        raise InvalidParamError(mode, ACCEPT_MODE)
    self.setAcceptMode(ACCEPT_MODE[mode])

set_directory(path: datatypes.PathType)

Set start directory.

Source code in prettyqt\widgets\filedialog.py

def set_directory(self, path: datatypes.PathType):
    """Set start directory."""
    path = os.fspath(path)
    self.setDirectory(path)

set_extension_filter(extension_dict: dict[str, list[str]])

Set filter based on given dictionary.

dict must contain "'name': ['.ext1', '.ext2']" as key-value pairs

Parameters:

Name	Type	Description	Default
extension_dict	dict[str, list[str]]	filter dictionary	required

Source code in prettyqt\widgets\filedialog.py

def set_extension_filter(self, extension_dict: dict[str, list[str]]):
    """Set filter based on given dictionary.

    dict must contain "'name': ['.ext1', '.ext2']" as key-value pairs

    Args:
        extension_dict: filter dictionary
    """
    items = [
        f"{k} ({' '.join(f'*{ext}' for ext in v)})" for k, v in extension_dict.items()
    ]
    filter_str = ";;".join(items)
    self.setNameFilter(filter_str)

set_file_mode(mode: FileModeStr)

Set the file mode of the dialog.

Parameters:

Name	Type	Description	Default
mode	FileModeStr	mode to use	required

Source code in prettyqt\widgets\filedialog.py

def set_file_mode(self, mode: FileModeStr):
    """Set the file mode of the dialog.

    Args:
        mode: mode to use
    """
    self.setFileMode(FILE_MODE[mode])

set_filter(*filters: core.dir.FilterStr)

Source code in prettyqt\widgets\filedialog.py

def set_filter(self, *filters: core.dir.FilterStr):
    for item in filters:
        if item not in core.dir.FILTERS:
            raise InvalidParamError(item, core.dir.FILTERS)
    flags = helpers.merge_flags(filters, core.dir.FILTERS)
    self.setFilter(flags)

set_label_text(label: LabelStr, text: str)

Set the label text for button label.

Parameters:

Name	Type	Description	Default
label	LabelStr	button to set text for	required
text	str	text to use	required

Source code in prettyqt\widgets\filedialog.py

def set_label_text(self, label: LabelStr, text: str):
    """Set the label text for button label.

    Args:
        label: button to set text for
        text: text to use
    """
    if label not in LABEL:
        raise InvalidParamError(label, LABEL)
    self.setLabelText(LABEL[label], text)

set_view_mode(mode: ViewModeStr)

Set view mode.

Parameters:

Name	Type	Description	Default
mode	ViewModeStr	view mode to use	required

Raises:

Type	Description
InvalidParamError	invalid view mode

Source code in prettyqt\widgets\filedialog.py

def set_view_mode(self, mode: ViewModeStr):
    """Set view mode.

    Args:
        mode: view mode to use

    Raises:
        InvalidParamError: invalid view mode
    """
    if mode not in VIEW_MODE:
        raise InvalidParamError(mode, VIEW_MODE)
    self.setViewMode(VIEW_MODE[mode])

FileIconProvider

Bases: gui.AbstractFileIconProviderMixin, QtWidgets.QFileIconProvider

Source code in prettyqt\widgets\fileiconprovider.py

class FileIconProvider(gui.AbstractFileIconProviderMixin, QtWidgets.QFileIconProvider):
    def get_icon(
        self,
        typ: gui.abstractfileiconprovider.IconTypeStr
        | QtCore.QFileInfo
        | datatypes.PathType,
    ) -> QtGui.QIcon:
        if isinstance(typ, os.PathLike | QtCore.QFileInfo):
            param = core.FileInfo(typ)
        else:
            param = gui.abstractfileiconprovider.ICON_TYPE[typ]
        return self.icon(param)

get_icon(typ: gui.abstractfileiconprovider.IconTypeStr | QtCore.QFileInfo | datatypes.PathType) -> QtGui.QIcon

Source code in prettyqt\widgets\fileiconprovider.py

def get_icon(
    self,
    typ: gui.abstractfileiconprovider.IconTypeStr
    | QtCore.QFileInfo
    | datatypes.PathType,
) -> QtGui.QIcon:
    if isinstance(typ, os.PathLike | QtCore.QFileInfo):
        param = core.FileInfo(typ)
    else:
        param = gui.abstractfileiconprovider.ICON_TYPE[typ]
    return self.icon(param)

FileSystemModel

Bases: FileSystemModelMixin, core.AbstractItemModelMixin, QtWidgets.QFileSystemModel

Source code in prettyqt\widgets\filesystemmodel.py

class FileSystemModel(
    FileSystemModelMixin, core.AbstractItemModelMixin, QtWidgets.QFileSystemModel
):
    pass

FocusFrame

Bases: widgets.WidgetMixin, QtWidgets.QFocusFrame

Source code in prettyqt\widgets\focusframe.py

class FocusFrame(widgets.WidgetMixin, QtWidgets.QFocusFrame):
    pass

FontComboBox

Bases: widgets.ComboBoxMixin, QtWidgets.QFontComboBox

Source code in prettyqt\widgets\fontcombobox.py

class FontComboBox(widgets.ComboBoxMixin, QtWidgets.QFontComboBox):
    value_changed = core.Signal(object)

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.currentIndexChanged.connect(self.index_changed)

    def set_font_filters(self, *filters: FontFilterStr):
        """Set font filters.

        Args:
            filters: font filters to use

        Raises:
            InvalidParamError: invalid font filters
        """
        if not filters:
            filters = ("all",)
        for item in filters:
            if item not in FONT_FILTERS:
                raise InvalidParamError(item, FONT_FILTERS)
        flags = helpers.merge_flags(filters, FONT_FILTERS)
        self.setFontFilters(flags)

    def get_font_filters(self) -> list[FontFilterStr]:
        """Return list of font filters.

        Returns:
            font filter list
        """
        return FONT_FILTERS.get_list(self.fontFilters())

    def set_value(self, value: QtGui.QFont):
        self.setCurrentFont(value)

    def get_value(self) -> gui.Font:
        return self.get_current_font()

    def get_current_font(self) -> gui.Font:
        return gui.Font(self.currentFont())

value_changed = core.Signal(object) class-attribute

__init__(*args, **kwargs)

Source code in prettyqt\widgets\fontcombobox.py

def __init__(self, *args, **kwargs):
    super().__init__(*args, **kwargs)
    self.currentIndexChanged.connect(self.index_changed)

get_current_font() -> gui.Font

Source code in prettyqt\widgets\fontcombobox.py

def get_current_font(self) -> gui.Font:
    return gui.Font(self.currentFont())

get_font_filters() -> list[FontFilterStr]

Return list of font filters.

Returns:

Type	Description
list[FontFilterStr]	font filter list

Source code in prettyqt\widgets\fontcombobox.py

def get_font_filters(self) -> list[FontFilterStr]:
    """Return list of font filters.

    Returns:
        font filter list
    """
    return FONT_FILTERS.get_list(self.fontFilters())

get_value() -> gui.Font

Source code in prettyqt\widgets\fontcombobox.py

def get_value(self) -> gui.Font:
    return self.get_current_font()

set_font_filters(*filters: FontFilterStr)

Set font filters.

Parameters:

Name	Type	Description	Default
filters	FontFilterStr	font filters to use	()

Raises:

Type	Description
InvalidParamError	invalid font filters

Source code in prettyqt\widgets\fontcombobox.py

def set_font_filters(self, *filters: FontFilterStr):
    """Set font filters.

    Args:
        filters: font filters to use

    Raises:
        InvalidParamError: invalid font filters
    """
    if not filters:
        filters = ("all",)
    for item in filters:
        if item not in FONT_FILTERS:
            raise InvalidParamError(item, FONT_FILTERS)
    flags = helpers.merge_flags(filters, FONT_FILTERS)
    self.setFontFilters(flags)

set_value(value: QtGui.QFont)

Source code in prettyqt\widgets\fontcombobox.py

def set_value(self, value: QtGui.QFont):
    self.setCurrentFont(value)

FontDialog

Bases: widgets.DialogMixin, QtWidgets.QFontDialog

Source code in prettyqt\widgets\fontdialog.py

class FontDialog(widgets.DialogMixin, QtWidgets.QFontDialog):
    def get_current_font(self) -> gui.Font:
        return gui.Font(self.currentFont())

get_current_font() -> gui.Font

Source code in prettyqt\widgets\fontdialog.py

def get_current_font(self) -> gui.Font:
    return gui.Font(self.currentFont())

FormLayout

Bases: widgets.LayoutMixin, QtWidgets.QFormLayout

Source code in prettyqt\widgets\formlayout.py

class FormLayout(widgets.LayoutMixin, QtWidgets.QFormLayout):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.set_size_constraint("maximum")
        self.setVerticalSpacing(8)

    def __setitem__(
        self, index: int | tuple[int, RoleStr], value: str | QtWidgets.QWidget
    ):
        if isinstance(index, tuple):
            row = index[0]
            role = index[1]
        else:
            row = index
            role = "both"
        self.set_widget(value, row, role)

    def __delitem__(self, index: int):
        self.removeRow(index)

    def __iter__(self) -> Iterator[QtWidgets.QWidget | QtWidgets.QLayout]:
        return iter(self[i] for i in range(self.count()) if self[i] is not None)

    def __len__(self) -> int:
        """Needed for PySide2."""
        return self.rowCount()

    def __add__(self, other: QtWidgets.QWidget | QtWidgets.QLayout | tuple):
        self.add(other)
        return self

    # def serialize_fields(self):
    #     widget_list = []
    #     positions = []
    #     for i, item in enumerate(list(self)):
    #         widget_list.append(item)
    #         positions.append(self.get_item_position(i))
    #     return dict(widgets=widget_list, positions=positions)

    # def __reduce__(self):
    #     return type(self), (), self.__getstate__()

    # def __setstate__(self, state):
    #     for item, pos in zip(state["widgets"], state["positions"]):
    #         self.set_widget(item, pos[0], pos[1])

    def set_widget(
        self, widget: str | QtWidgets.QWidget, row: int, role: RoleStr = "both"
    ):
        if isinstance(widget, str):
            widget = widgets.Label(widget)
        self.setWidget(row, ROLE[role], widget)

    def get_widget(
        self, row: int, role: RoleStr = "both"
    ) -> QtWidgets.QLayout | QtWidgets.QWidget:
        item = self.itemAt(row, ROLE[role])
        widget = item.widget()
        if widget is None:
            widget = item.layout()
        return widget

    def get_item_position(self, index: int) -> tuple[int, RoleStr] | None:
        pos = self.getItemPosition(index)  # type: ignore
        return None if pos[0] == -1 else (pos[0], ROLE.inverse[pos[1]])

    def add(self, *items):
        for i in items:
            if isinstance(i, QtWidgets.QWidget | QtWidgets.QLayout):
                self.addRow(i)
            elif isinstance(i, tuple):
                self.addRow(*i)

    def set_row_wrap_policy(self, policy: RowWrapPolicyStr):
        """Set row wrap policy to use.

        Args:
            policy: row wrap policy to use

        Raises:
            InvalidParamError: row wrap policy does not exist
        """
        if policy not in ROW_WRAP_POLICY:
            raise InvalidParamError(policy, ROW_WRAP_POLICY)
        self.setRowWrapPolicy(ROW_WRAP_POLICY[policy])

    def get_row_wrap_policy(self) -> RowWrapPolicyStr:
        """Return current row wrap policy.

        Returns:
            row wrap policy
        """
        return ROW_WRAP_POLICY.inverse[self.rowWrapPolicy()]

    def set_field_growth_policy(self, policy: FieldGrowthPolicyStr):
        """Set field growth policy to use.

        Args:
            policy: field growth policy to use

        Raises:
            InvalidParamError: field growth policy does not exist
        """
        if policy not in FIELD_GROWTH_POLICY:
            raise InvalidParamError(policy, FIELD_GROWTH_POLICY)
        self.setFieldGrowthPolicy(FIELD_GROWTH_POLICY[policy])

    def get_field_growth_policy(self) -> FieldGrowthPolicyStr:
        """Return current field growth policy.

        Returns:
            field growth policy
        """
        return FIELD_GROWTH_POLICY.inverse[self.fieldGrowthPolicy()]

__add__(other: QtWidgets.QWidget | QtWidgets.QLayout | tuple)

Source code in prettyqt\widgets\formlayout.py

def __add__(self, other: QtWidgets.QWidget | QtWidgets.QLayout | tuple):
    self.add(other)
    return self

__delitem__(index: int)

Source code in prettyqt\widgets\formlayout.py

def __delitem__(self, index: int):
    self.removeRow(index)

__init__(*args, **kwargs)

Source code in prettyqt\widgets\formlayout.py

def __init__(self, *args, **kwargs):
    super().__init__(*args, **kwargs)
    self.set_size_constraint("maximum")
    self.setVerticalSpacing(8)

__iter__() -> Iterator[QtWidgets.QWidget | QtWidgets.QLayout]

Source code in prettyqt\widgets\formlayout.py

def __iter__(self) -> Iterator[QtWidgets.QWidget | QtWidgets.QLayout]:
    return iter(self[i] for i in range(self.count()) if self[i] is not None)

__len__() -> int

Needed for PySide2.

Source code in prettyqt\widgets\formlayout.py

def __len__(self) -> int:
    """Needed for PySide2."""
    return self.rowCount()

__setitem__(index: int | tuple[int, RoleStr], value: str | QtWidgets.QWidget)

Source code in prettyqt\widgets\formlayout.py

def __setitem__(
    self, index: int | tuple[int, RoleStr], value: str | QtWidgets.QWidget
):
    if isinstance(index, tuple):
        row = index[0]
        role = index[1]
    else:
        row = index
        role = "both"
    self.set_widget(value, row, role)

add(*items)

Source code in prettyqt\widgets\formlayout.py

def add(self, *items):
    for i in items:
        if isinstance(i, QtWidgets.QWidget | QtWidgets.QLayout):
            self.addRow(i)
        elif isinstance(i, tuple):
            self.addRow(*i)

get_field_growth_policy() -> FieldGrowthPolicyStr

Return current field growth policy.

Returns:

Type	Description
FieldGrowthPolicyStr	field growth policy

Source code in prettyqt\widgets\formlayout.py

def get_field_growth_policy(self) -> FieldGrowthPolicyStr:
    """Return current field growth policy.

    Returns:
        field growth policy
    """
    return FIELD_GROWTH_POLICY.inverse[self.fieldGrowthPolicy()]

get_item_position(index: int) -> tuple[int, RoleStr] | None

Source code in prettyqt\widgets\formlayout.py

def get_item_position(self, index: int) -> tuple[int, RoleStr] | None:
    pos = self.getItemPosition(index)  # type: ignore
    return None if pos[0] == -1 else (pos[0], ROLE.inverse[pos[1]])

get_row_wrap_policy() -> RowWrapPolicyStr

Return current row wrap policy.

Returns:

Type	Description
RowWrapPolicyStr	row wrap policy

Source code in prettyqt\widgets\formlayout.py

def get_row_wrap_policy(self) -> RowWrapPolicyStr:
    """Return current row wrap policy.

    Returns:
        row wrap policy
    """
    return ROW_WRAP_POLICY.inverse[self.rowWrapPolicy()]

get_widget(row: int, role: RoleStr = 'both') -> QtWidgets.QLayout | QtWidgets.QWidget

Source code in prettyqt\widgets\formlayout.py

def get_widget(
    self, row: int, role: RoleStr = "both"
) -> QtWidgets.QLayout | QtWidgets.QWidget:
    item = self.itemAt(row, ROLE[role])
    widget = item.widget()
    if widget is None:
        widget = item.layout()
    return widget

set_field_growth_policy(policy: FieldGrowthPolicyStr)

Set field growth policy to use.

Parameters:

Name	Type	Description	Default
policy	FieldGrowthPolicyStr	field growth policy to use	required

Raises:

Type	Description
InvalidParamError	field growth policy does not exist

Source code in prettyqt\widgets\formlayout.py

def set_field_growth_policy(self, policy: FieldGrowthPolicyStr):
    """Set field growth policy to use.

    Args:
        policy: field growth policy to use

    Raises:
        InvalidParamError: field growth policy does not exist
    """
    if policy not in FIELD_GROWTH_POLICY:
        raise InvalidParamError(policy, FIELD_GROWTH_POLICY)
    self.setFieldGrowthPolicy(FIELD_GROWTH_POLICY[policy])

set_row_wrap_policy(policy: RowWrapPolicyStr)

Set row wrap policy to use.

Parameters:

Name	Type	Description	Default
policy	RowWrapPolicyStr	row wrap policy to use	required

Raises:

Type	Description
InvalidParamError	row wrap policy does not exist

Source code in prettyqt\widgets\formlayout.py

def set_row_wrap_policy(self, policy: RowWrapPolicyStr):
    """Set row wrap policy to use.

    Args:
        policy: row wrap policy to use

    Raises:
        InvalidParamError: row wrap policy does not exist
    """
    if policy not in ROW_WRAP_POLICY:
        raise InvalidParamError(policy, ROW_WRAP_POLICY)
    self.setRowWrapPolicy(ROW_WRAP_POLICY[policy])

set_widget(widget: str | QtWidgets.QWidget, row: int, role: RoleStr = 'both')

Source code in prettyqt\widgets\formlayout.py

def set_widget(
    self, widget: str | QtWidgets.QWidget, row: int, role: RoleStr = "both"
):
    if isinstance(widget, str):
        widget = widgets.Label(widget)
    self.setWidget(row, ROLE[role], widget)

Frame

Bases: FrameMixin, QtWidgets.QFrame

Source code in prettyqt\widgets\frame.py

class Frame(FrameMixin, QtWidgets.QFrame):
    pass

FrameMixin

Bases: widgets.WidgetMixin

Source code in prettyqt\widgets\frame.py

class FrameMixin(widgets.WidgetMixin):
    def set_frame_shadow(self, style: ShadowStr):
        """Set frame shadow.

        Args:
            style: frame style to use

        Raises:
            InvalidParamError: style does not exist
        """
        if style is None:
            return
        if style not in SHADOW:
            raise InvalidParamError(style, SHADOW)
        self.setFrameShadow(SHADOW[style])

    def get_frame_shadow(self) -> ShadowStr | None:
        """Return current frame shadow.

        Returns:
            frame style
        """
        if (frame_shadow := self.frameShadow()) == 0:
            return None
        return SHADOW.inverse[frame_shadow]

    def set_frame_shape(self, shape: FrameShapeStr):
        """Set frame shape.

        Args:
            shape: frame shape to use

        Raises:
            InvalidParamError: shape does not exist
        """
        if shape not in FRAME_SHAPE:
            raise InvalidParamError(shape, FRAME_SHAPE)
        self.setFrameShape(FRAME_SHAPE[shape])

    def get_frame_shape(self) -> FrameShapeStr:
        """Return current frame shape.

        Returns:
            frame shape
        """
        return FRAME_SHAPE.inverse[self.frameShape()]

get_frame_shadow() -> ShadowStr | None

Return current frame shadow.

Returns:

Type	Description
ShadowStr | None	frame style

Source code in prettyqt\widgets\frame.py

def get_frame_shadow(self) -> ShadowStr | None:
    """Return current frame shadow.

    Returns:
        frame style
    """
    if (frame_shadow := self.frameShadow()) == 0:
        return None
    return SHADOW.inverse[frame_shadow]

get_frame_shape() -> FrameShapeStr

Return current frame shape.

Returns:

Type	Description
FrameShapeStr	frame shape

Source code in prettyqt\widgets\frame.py

def get_frame_shape(self) -> FrameShapeStr:
    """Return current frame shape.

    Returns:
        frame shape
    """
    return FRAME_SHAPE.inverse[self.frameShape()]

set_frame_shadow(style: ShadowStr)

Set frame shadow.

Parameters:

Name	Type	Description	Default
style	ShadowStr	frame style to use	required

Raises:

Type	Description
InvalidParamError	style does not exist

Source code in prettyqt\widgets\frame.py

def set_frame_shadow(self, style: ShadowStr):
    """Set frame shadow.

    Args:
        style: frame style to use

    Raises:
        InvalidParamError: style does not exist
    """
    if style is None:
        return
    if style not in SHADOW:
        raise InvalidParamError(style, SHADOW)
    self.setFrameShadow(SHADOW[style])

set_frame_shape(shape: FrameShapeStr)

Set frame shape.

Parameters:

Name	Type	Description	Default
shape	FrameShapeStr	frame shape to use	required

Raises:

Type	Description
InvalidParamError	shape does not exist

Source code in prettyqt\widgets\frame.py

def set_frame_shape(self, shape: FrameShapeStr):
    """Set frame shape.

    Args:
        shape: frame shape to use

    Raises:
        InvalidParamError: shape does not exist
    """
    if shape not in FRAME_SHAPE:
        raise InvalidParamError(shape, FRAME_SHAPE)
    self.setFrameShape(FRAME_SHAPE[shape])

Gesture

Bases: GestureMixin, QtWidgets.QGesture

Source code in prettyqt\widgets\gesture.py

class Gesture(GestureMixin, QtWidgets.QGesture):
    pass

GestureMixin

Bases: core.ObjectMixin

Source code in prettyqt\widgets\gesture.py

class GestureMixin(core.ObjectMixin):
    def get_state(self) -> constants.GestureStateStr:
        """Return current state.

        Returns:
            state
        """
        return constants.GESTURE_STATE.inverse[self.state()]

    def get_gesture_type(self) -> constants.GestureTypeStr:
        """Return current gesture type.

        Returns:
            gesture type
        """
        return constants.GESTURE_TYPE.inverse[self.gestureType()]

    def get_hot_spot(self) -> core.PointF:
        return core.PointF(self.hotSpot())

    def set_gesture_cancel_policy(self, policy: GestureCancelPolicyStr):
        """Set gesture cancel policy.

        Args:
            policy: gesture cancel policy to use

        Raises:
            InvalidParamError: gesture cancel policy does not exist
        """
        if policy not in GESTURE_CANCEL_POLICY:
            raise InvalidParamError(policy, GESTURE_CANCEL_POLICY)
        self.setGestureCancelPolicy(GESTURE_CANCEL_POLICY[policy])

    def get_gesture_cancel_policy(self) -> GestureCancelPolicyStr:
        """Return current gesture cancel policy.

        Returns:
            gesture cancel policy
        """
        return GESTURE_CANCEL_POLICY.inverse[self.gestureCancelPolicy()]

get_gesture_cancel_policy() -> GestureCancelPolicyStr

Return current gesture cancel policy.

Returns:

Type	Description
GestureCancelPolicyStr	gesture cancel policy

Source code in prettyqt\widgets\gesture.py

def get_gesture_cancel_policy(self) -> GestureCancelPolicyStr:
    """Return current gesture cancel policy.

    Returns:
        gesture cancel policy
    """
    return GESTURE_CANCEL_POLICY.inverse[self.gestureCancelPolicy()]

get_gesture_type() -> constants.GestureTypeStr

Return current gesture type.

Returns:

Type	Description
constants.GestureTypeStr	gesture type

Source code in prettyqt\widgets\gesture.py

def get_gesture_type(self) -> constants.GestureTypeStr:
    """Return current gesture type.

    Returns:
        gesture type
    """
    return constants.GESTURE_TYPE.inverse[self.gestureType()]

get_hot_spot() -> core.PointF

Source code in prettyqt\widgets\gesture.py

def get_hot_spot(self) -> core.PointF:
    return core.PointF(self.hotSpot())

get_state() -> constants.GestureStateStr

Return current state.

Returns:

Type	Description
constants.GestureStateStr	state

Source code in prettyqt\widgets\gesture.py

def get_state(self) -> constants.GestureStateStr:
    """Return current state.

    Returns:
        state
    """
    return constants.GESTURE_STATE.inverse[self.state()]

set_gesture_cancel_policy(policy: GestureCancelPolicyStr)

Set gesture cancel policy.

Parameters:

Name	Type	Description	Default
policy	GestureCancelPolicyStr	gesture cancel policy to use	required

Raises:

Type	Description
InvalidParamError	gesture cancel policy does not exist

Source code in prettyqt\widgets\gesture.py

def set_gesture_cancel_policy(self, policy: GestureCancelPolicyStr):
    """Set gesture cancel policy.

    Args:
        policy: gesture cancel policy to use

    Raises:
        InvalidParamError: gesture cancel policy does not exist
    """
    if policy not in GESTURE_CANCEL_POLICY:
        raise InvalidParamError(policy, GESTURE_CANCEL_POLICY)
    self.setGestureCancelPolicy(GESTURE_CANCEL_POLICY[policy])

GraphicsAnchorLayout

Bases: widgets.GraphicsLayoutMixin, QtWidgets.QGraphicsAnchorLayout

Source code in prettyqt\widgets\graphicsanchorlayout.py

class GraphicsAnchorLayout(widgets.GraphicsLayoutMixin, QtWidgets.QGraphicsAnchorLayout):
    def add_anchor(
        self,
        first_item: QtWidgets.QGraphicsLayoutItem,
        first_edge: constants.AnchorPointStr,
        second_item: QtWidgets.QGraphicsLayoutItem,
        second_edge: constants.AnchorPointStr,
    ) -> QtWidgets.QGraphicsAnchor:
        return self.addAnchor(
            first_item,
            constants.ANCHOR_POINT[first_edge],
            second_item,
            constants.ANCHOR_POINT[second_edge],
        )

    def get_anchor(
        self,
        first_item: QtWidgets.QGraphicsLayoutItem,
        first_edge: constants.AnchorPointStr,
        second_item: QtWidgets.QGraphicsLayoutItem,
        second_edge: constants.AnchorPointStr,
    ) -> QtWidgets.QGraphicsAnchor:
        return self.anchor(
            first_item,
            constants.ANCHOR_POINT[first_edge],
            second_item,
            constants.ANCHOR_POINT[second_edge],
        )

    def add_anchors(
        self,
        first_item: QtWidgets.QGraphicsLayoutItem,
        second_item: QtWidgets.QGraphicsLayoutItem,
        orientation: constants.OrientationStr,
    ):
        if orientation not in constants.ORIENTATION:
            raise InvalidParamError(orientation, constants.ORIENTATION)
        self.addAnchors(
            first_item, second_item, constants.ORIENTATION[orientation]  # type: ignore
        )

    def add_corner_anchors(
        self,
        first_item: QtWidgets.QGraphicsLayoutItem,
        first_corner: constants.CornerStr,
        second_item: QtWidgets.QGraphicsLayoutItem,
        second_corner: constants.CornerStr,
    ):
        self.addCornerAnchors(
            first_item,
            constants.CORNER[first_corner],
            second_item,
            constants.CORNER[second_corner],
        )

add_anchor(first_item: QtWidgets.QGraphicsLayoutItem, first_edge: constants.AnchorPointStr, second_item: QtWidgets.QGraphicsLayoutItem, second_edge: constants.AnchorPointStr) -> QtWidgets.QGraphicsAnchor

Source code in prettyqt\widgets\graphicsanchorlayout.py

def add_anchor(
    self,
    first_item: QtWidgets.QGraphicsLayoutItem,
    first_edge: constants.AnchorPointStr,
    second_item: QtWidgets.QGraphicsLayoutItem,
    second_edge: constants.AnchorPointStr,
) -> QtWidgets.QGraphicsAnchor:
    return self.addAnchor(
        first_item,
        constants.ANCHOR_POINT[first_edge],
        second_item,
        constants.ANCHOR_POINT[second_edge],
    )

add_anchors(first_item: QtWidgets.QGraphicsLayoutItem, second_item: QtWidgets.QGraphicsLayoutItem, orientation: constants.OrientationStr)

Source code in prettyqt\widgets\graphicsanchorlayout.py

def add_anchors(
    self,
    first_item: QtWidgets.QGraphicsLayoutItem,
    second_item: QtWidgets.QGraphicsLayoutItem,
    orientation: constants.OrientationStr,
):
    if orientation not in constants.ORIENTATION:
        raise InvalidParamError(orientation, constants.ORIENTATION)
    self.addAnchors(
        first_item, second_item, constants.ORIENTATION[orientation]  # type: ignore
    )

add_corner_anchors(first_item: QtWidgets.QGraphicsLayoutItem, first_corner: constants.CornerStr, second_item: QtWidgets.QGraphicsLayoutItem, second_corner: constants.CornerStr)

Source code in prettyqt\widgets\graphicsanchorlayout.py

def add_corner_anchors(
    self,
    first_item: QtWidgets.QGraphicsLayoutItem,
    first_corner: constants.CornerStr,
    second_item: QtWidgets.QGraphicsLayoutItem,
    second_corner: constants.CornerStr,
):
    self.addCornerAnchors(
        first_item,
        constants.CORNER[first_corner],
        second_item,
        constants.CORNER[second_corner],
    )

get_anchor(first_item: QtWidgets.QGraphicsLayoutItem, first_edge: constants.AnchorPointStr, second_item: QtWidgets.QGraphicsLayoutItem, second_edge: constants.AnchorPointStr) -> QtWidgets.QGraphicsAnchor

Source code in prettyqt\widgets\graphicsanchorlayout.py

def get_anchor(
    self,
    first_item: QtWidgets.QGraphicsLayoutItem,
    first_edge: constants.AnchorPointStr,
    second_item: QtWidgets.QGraphicsLayoutItem,
    second_edge: constants.AnchorPointStr,
) -> QtWidgets.QGraphicsAnchor:
    return self.anchor(
        first_item,
        constants.ANCHOR_POINT[first_edge],
        second_item,
        constants.ANCHOR_POINT[second_edge],
    )

GraphicsBlurEffect

Bases: widgets.GraphicsEffectMixin, QtWidgets.QGraphicsBlurEffect

Source code in prettyqt\widgets\graphicsblureffect.py

class GraphicsBlurEffect(widgets.GraphicsEffectMixin, QtWidgets.QGraphicsBlurEffect):
    def set_blur_hints(self, *hints: BlurHintStr):
        for item in hints:
            if item not in BLUR_HINTS:
                raise InvalidParamError(item, BLUR_HINTS)
        if hints:
            flags = helpers.merge_flags(hints, BLUR_HINTS)
        else:
            flags = QtWidgets.QGraphicsBlurEffect.BlurHint(0)  # type: ignore
        self.setBlurHints(flags)

    def get_blur_hints(self) -> list[BlurHintStr]:
        return BLUR_HINTS.get_list(self.blurHints())

get_blur_hints() -> list[BlurHintStr]

Source code in prettyqt\widgets\graphicsblureffect.py

def get_blur_hints(self) -> list[BlurHintStr]:
    return BLUR_HINTS.get_list(self.blurHints())

set_blur_hints(*hints: BlurHintStr)

Source code in prettyqt\widgets\graphicsblureffect.py

def set_blur_hints(self, *hints: BlurHintStr):
    for item in hints:
        if item not in BLUR_HINTS:
            raise InvalidParamError(item, BLUR_HINTS)
    if hints:
        flags = helpers.merge_flags(hints, BLUR_HINTS)
    else:
        flags = QtWidgets.QGraphicsBlurEffect.BlurHint(0)  # type: ignore
    self.setBlurHints(flags)

GraphicsColorizeEffect

Bases: widgets.GraphicsEffectMixin, QtWidgets.QGraphicsColorizeEffect

Source code in prettyqt\widgets\graphicscolorizeeffect.py

class GraphicsColorizeEffect(
    widgets.GraphicsEffectMixin, QtWidgets.QGraphicsColorizeEffect
):
    def serialize_fields(self):
        return dict(strength=self.strength(), color=gui.Color(self.color()))

    def __setstate__(self, state):
        super().__setstate__(state)
        self.setStrength(state["strength"])
        self.setColor(state["color"])

__setstate__(state)

Source code in prettyqt\widgets\graphicscolorizeeffect.py

def __setstate__(self, state):
    super().__setstate__(state)
    self.setStrength(state["strength"])
    self.setColor(state["color"])

serialize_fields()

Source code in prettyqt\widgets\graphicscolorizeeffect.py

def serialize_fields(self):
    return dict(strength=self.strength(), color=gui.Color(self.color()))

GraphicsDropShadowEffect

Bases: widgets.GraphicsEffectMixin, QtWidgets.QGraphicsDropShadowEffect

Source code in prettyqt\widgets\graphicsdropshadoweffect.py

class GraphicsDropShadowEffect(
    widgets.GraphicsEffectMixin, QtWidgets.QGraphicsDropShadowEffect
):
    def serialize_fields(self):
        offset = self.offset()
        return dict(
            blur_radius=self.blurRadius(),
            color=gui.Color(self.color()),
            offset=(offset.x(), offset.y()),
        )

serialize_fields()

Source code in prettyqt\widgets\graphicsdropshadoweffect.py

def serialize_fields(self):
    offset = self.offset()
    return dict(
        blur_radius=self.blurRadius(),
        color=gui.Color(self.color()),
        offset=(offset.x(), offset.y()),
    )

GraphicsEffect

Bases: GraphicsEffectMixin, QtWidgets.QGraphicsEffect

Source code in prettyqt\widgets\graphicseffect.py

class GraphicsEffect(GraphicsEffectMixin, QtWidgets.QGraphicsEffect):
    pass

GraphicsEffectMixin

Bases: core.ObjectMixin

Source code in prettyqt\widgets\graphicseffect.py

class GraphicsEffectMixin(core.ObjectMixin):
    pass

GraphicsEllipseItem

Bases: widgets.AbstractGraphicsShapeItemMixin, QtWidgets.QGraphicsEllipseItem

Source code in prettyqt\widgets\graphicsellipseitem.py

class GraphicsEllipseItem(
    widgets.AbstractGraphicsShapeItemMixin, QtWidgets.QGraphicsEllipseItem
):
    def __repr__(self):
        return get_repr(self, self.get_rect())

    def serialize_fields(self):
        return dict(
            rect=self.get_rect(),
            span_angle=self.spanAngle(),
            start_angle=self.startAngle(),
        )

    def get_rect(self) -> core.RectF:
        return core.RectF(self.rect())

__repr__()

Source code in prettyqt\widgets\graphicsellipseitem.py

def __repr__(self):
    return get_repr(self, self.get_rect())

get_rect() -> core.RectF

Source code in prettyqt\widgets\graphicsellipseitem.py

def get_rect(self) -> core.RectF:
    return core.RectF(self.rect())

serialize_fields()

Source code in prettyqt\widgets\graphicsellipseitem.py

def serialize_fields(self):
    return dict(
        rect=self.get_rect(),
        span_angle=self.spanAngle(),
        start_angle=self.startAngle(),
    )

GraphicsGridLayout

Bases: widgets.GraphicsLayoutMixin, QtWidgets.QGraphicsGridLayout

Source code in prettyqt\widgets\graphicsgridlayout.py

class GraphicsGridLayout(widgets.GraphicsLayoutMixin, QtWidgets.QGraphicsGridLayout):
    def __getitem__(
        self, idx: tuple[int, int] | int
    ) -> QtWidgets.QGraphicsLayoutItem | None:
        return self.itemAt(*idx) if isinstance(idx, tuple) else self.itemAt(idx)

    def __setitem__(
        self,
        idx: tuple[int | slice, int | slice],
        value: QtWidgets.QGraphicsLayoutItem,
    ):
        row, col = idx
        rowspan = row.stop - row.start + 1 if isinstance(row, slice) else 1
        colspan = col.stop - col.start + 1 if isinstance(col, slice) else 1
        rowstart = row.start if isinstance(row, slice) else row
        colstart = col.start if isinstance(col, slice) else col
        self.add(value, rowstart, colstart, rowspan, colspan)

    def serialize_fields(self):
        items = []
        positions = []
        for row in range(self.rowCount()):
            for col in range(self.columnCount()):
                item = self.itemAt(row, col)
                if item is not None:
                    items.append(item)
                    positions.append((row, col))
        return dict(widgets=items, positions=positions)

    def __reduce__(self):
        return type(self), (), self.__getstate__()

    def __setstate__(self, state):
        for item, pos in zip(state["widgets"], state["positions"]):
            x, y, w, h = pos
            self[x : x + w - 1, y : y + h - 1] = item

    def __iter__(self) -> Iterator[QtWidgets.QWidget | QtWidgets.QLayout]:
        return iter(self[i] for i in range(self.count()) if self[i] is not None)

    def __add__(
        self,
        other: (Iterable[QtWidgets.QGraphicsLayoutItem] | QtWidgets.QGraphicsLayoutItem),
    ):
        if isinstance(other, Iterable):
            for i, control in enumerate(other):
                self[self.rowCount(), i] = control
        else:
            self[self.rowCount(), 0 : self.columnCount() - 1] = other
        return self

    def add(
        self,
        item: QtWidgets.QGraphicsLayoutItem,
        rowstart: int,
        colstart: int,
        rowspan: int = 1,
        colspan: int = 1,
    ):
        self.addItem(item, rowstart, colstart, rowspan, colspan)

    def append(self, item: QtWidgets.QGraphicsLayoutItem):
        self[self.rowCount(), 0 : self.columnCount() - 1] = item

    def set_column_alignment(self, column: int, alignment: constants.AlignmentStr):
        if alignment not in constants.ALIGNMENTS:
            raise InvalidParamError(alignment, constants.ALIGNMENTS)
        self.setColumnAlignment(column, constants.ALIGNMENTS[alignment])

    def set_row_alignment(self, row: int, alignment: constants.AlignmentStr):
        if alignment not in constants.ALIGNMENTS:
            raise InvalidParamError(alignment, constants.ALIGNMENTS)
        self.setRowAlignment(row, constants.ALIGNMENTS[alignment])

__add__(other: Iterable[QtWidgets.QGraphicsLayoutItem] | QtWidgets.QGraphicsLayoutItem)

Source code in prettyqt\widgets\graphicsgridlayout.py

def __add__(
    self,
    other: (Iterable[QtWidgets.QGraphicsLayoutItem] | QtWidgets.QGraphicsLayoutItem),
):
    if isinstance(other, Iterable):
        for i, control in enumerate(other):
            self[self.rowCount(), i] = control
    else:
        self[self.rowCount(), 0 : self.columnCount() - 1] = other
    return self

__getitem__(idx: tuple[int, int] | int) -> QtWidgets.QGraphicsLayoutItem | None

Source code in prettyqt\widgets\graphicsgridlayout.py

def __getitem__(
    self, idx: tuple[int, int] | int
) -> QtWidgets.QGraphicsLayoutItem | None:
    return self.itemAt(*idx) if isinstance(idx, tuple) else self.itemAt(idx)

__iter__() -> Iterator[QtWidgets.QWidget | QtWidgets.QLayout]

Source code in prettyqt\widgets\graphicsgridlayout.py

def __iter__(self) -> Iterator[QtWidgets.QWidget | QtWidgets.QLayout]:
    return iter(self[i] for i in range(self.count()) if self[i] is not None)

__reduce__()

Source code in prettyqt\widgets\graphicsgridlayout.py

def __reduce__(self):
    return type(self), (), self.__getstate__()

__setitem__(idx: tuple[int | slice, int | slice], value: QtWidgets.QGraphicsLayoutItem)

Source code in prettyqt\widgets\graphicsgridlayout.py

def __setitem__(
    self,
    idx: tuple[int | slice, int | slice],
    value: QtWidgets.QGraphicsLayoutItem,
):
    row, col = idx
    rowspan = row.stop - row.start + 1 if isinstance(row, slice) else 1
    colspan = col.stop - col.start + 1 if isinstance(col, slice) else 1
    rowstart = row.start if isinstance(row, slice) else row
    colstart = col.start if isinstance(col, slice) else col
    self.add(value, rowstart, colstart, rowspan, colspan)

__setstate__(state)

Source code in prettyqt\widgets\graphicsgridlayout.py

def __setstate__(self, state):
    for item, pos in zip(state["widgets"], state["positions"]):
        x, y, w, h = pos
        self[x : x + w - 1, y : y + h - 1] = item

add(item: QtWidgets.QGraphicsLayoutItem, rowstart: int, colstart: int, rowspan: int = 1, colspan: int = 1)

Source code in prettyqt\widgets\graphicsgridlayout.py

def add(
    self,
    item: QtWidgets.QGraphicsLayoutItem,
    rowstart: int,
    colstart: int,
    rowspan: int = 1,
    colspan: int = 1,
):
    self.addItem(item, rowstart, colstart, rowspan, colspan)

append(item: QtWidgets.QGraphicsLayoutItem)

Source code in prettyqt\widgets\graphicsgridlayout.py

def append(self, item: QtWidgets.QGraphicsLayoutItem):
    self[self.rowCount(), 0 : self.columnCount() - 1] = item

serialize_fields()

Source code in prettyqt\widgets\graphicsgridlayout.py

def serialize_fields(self):
    items = []
    positions = []
    for row in range(self.rowCount()):
        for col in range(self.columnCount()):
            item = self.itemAt(row, col)
            if item is not None:
                items.append(item)
                positions.append((row, col))
    return dict(widgets=items, positions=positions)

set_column_alignment(column: int, alignment: constants.AlignmentStr)

Source code in prettyqt\widgets\graphicsgridlayout.py

def set_column_alignment(self, column: int, alignment: constants.AlignmentStr):
    if alignment not in constants.ALIGNMENTS:
        raise InvalidParamError(alignment, constants.ALIGNMENTS)
    self.setColumnAlignment(column, constants.ALIGNMENTS[alignment])

set_row_alignment(row: int, alignment: constants.AlignmentStr)

Source code in prettyqt\widgets\graphicsgridlayout.py

def set_row_alignment(self, row: int, alignment: constants.AlignmentStr):
    if alignment not in constants.ALIGNMENTS:
        raise InvalidParamError(alignment, constants.ALIGNMENTS)
    self.setRowAlignment(row, constants.ALIGNMENTS[alignment])

GraphicsItem

Bases: GraphicsItemMixin, QtWidgets.QGraphicsItem

Source code in prettyqt\widgets\graphicsitem.py

class GraphicsItem(GraphicsItemMixin, QtWidgets.QGraphicsItem):
    pass

GraphicsItemGroup

Bases: widgets.GraphicsItemMixin, QtWidgets.QGraphicsItemGroup

Source code in prettyqt\widgets\graphicsitemgroup.py

class GraphicsItemGroup(widgets.GraphicsItemMixin, QtWidgets.QGraphicsItemGroup):
    pass

GraphicsItemMixin

Source code in prettyqt\widgets\graphicsitem.py

class GraphicsItemMixin:
    def __repr__(self):
        return get_repr(self)

    def __contains__(self, value: QtCore.QPointF) -> bool:
        return self.contains(value)

    def __getitem__(self, key: int):
        return self.data(key)

    def __setitem__(self, key: int, value):
        self.setData(key, value)

    def set_focus(self, reason: constants.FocusReasonStr = "other"):
        if reason not in constants.FOCUS_REASONS:
            raise InvalidParamError(reason, constants.FOCUS_REASONS)
        self.setFocus(constants.FOCUS_REASONS[reason])

    def colliding_items(
        self, mode: constants.ItemSelectionModeStr = "intersects_shape"
    ) -> list[QtWidgets.QGraphicsItem]:
        if mode not in constants.ITEM_SELECTION_MODE:
            raise InvalidParamError(mode, constants.ITEM_SELECTION_MODE)
        return self.collidingItems(constants.ITEM_SELECTION_MODE[mode])

    def collides_with(
        self,
        item: QtGui.QPainterPath | QtWidgets.QGraphicsItem,
        mode: constants.ItemSelectionModeStr = "intersects_shape",
    ) -> bool:
        if mode not in constants.ITEM_SELECTION_MODE:
            raise InvalidParamError(mode, constants.ITEM_SELECTION_MODE)
        if isinstance(item, QtGui.QPainterPath):
            return self.collidesWithPath(item, constants.ITEM_SELECTION_MODE[mode])
        else:
            return self.collidesWithItem(item, constants.ITEM_SELECTION_MODE[mode])

    def set_panel_modality(self, modality: PanelModalityStr) -> None:
        """Set panel modality.

        Args:
            modality: panel modality

        Raises:
            InvalidParamError: panel modality does not exist
        """
        if modality not in PANEL_MODALITY:
            raise InvalidParamError(modality, PANEL_MODALITY)
        self.setPanelModality(PANEL_MODALITY[modality])

    def get_panel_modality(self) -> PanelModalityStr:
        """Get the current modality modes as a string.

        Returns:
            panel modality
        """
        return PANEL_MODALITY.inverse[self.panelModality()]

    def set_cache_mode(self, mode: CacheModeStr) -> None:
        """Set cache mode.

        Args:
            mode: cache mode

        Raises:
            InvalidParamError: cache mode does not exist
        """
        if mode not in CACHE_MODE:
            raise InvalidParamError(mode, CACHE_MODE)
        self.setCacheMode(CACHE_MODE[mode])

    def get_cache_mode(self) -> CacheModeStr:
        """Get the current mode modes as a string.

        Returns:
            cache mode
        """
        return CACHE_MODE.inverse[self.cacheMode()]

    def get_shape(self) -> gui.PainterPath:
        return gui.PainterPath(self.shape())

    def set_scale(self, scale: tuple[float, float] | float):
        if isinstance(scale, float):
            self.setScale(scale)
        else:
            self.setTransform(gui.Transform.fromScale(scale[0], scale[1]), True)

    def set_transform(self, transform: datatypes.TransformType, combine: bool = False):
        if isinstance(transform, tuple):
            transform = gui.Transform(*transform)
        self.setTransform(transform, combine)

__contains__(value: QtCore.QPointF) -> bool

Source code in prettyqt\widgets\graphicsitem.py

def __contains__(self, value: QtCore.QPointF) -> bool:
    return self.contains(value)

__getitem__(key: int)

Source code in prettyqt\widgets\graphicsitem.py

def __getitem__(self, key: int):
    return self.data(key)

__repr__()

Source code in prettyqt\widgets\graphicsitem.py

def __repr__(self):
    return get_repr(self)

__setitem__(key: int, value)

Source code in prettyqt\widgets\graphicsitem.py

def __setitem__(self, key: int, value):
    self.setData(key, value)

collides_with(item: QtGui.QPainterPath | QtWidgets.QGraphicsItem, mode: constants.ItemSelectionModeStr = 'intersects_shape') -> bool

Source code in prettyqt\widgets\graphicsitem.py

def collides_with(
    self,
    item: QtGui.QPainterPath | QtWidgets.QGraphicsItem,
    mode: constants.ItemSelectionModeStr = "intersects_shape",
) -> bool:
    if mode not in constants.ITEM_SELECTION_MODE:
        raise InvalidParamError(mode, constants.ITEM_SELECTION_MODE)
    if isinstance(item, QtGui.QPainterPath):
        return self.collidesWithPath(item, constants.ITEM_SELECTION_MODE[mode])
    else:
        return self.collidesWithItem(item, constants.ITEM_SELECTION_MODE[mode])

colliding_items(mode: constants.ItemSelectionModeStr = 'intersects_shape') -> list[QtWidgets.QGraphicsItem]

Source code in prettyqt\widgets\graphicsitem.py

def colliding_items(
    self, mode: constants.ItemSelectionModeStr = "intersects_shape"
) -> list[QtWidgets.QGraphicsItem]:
    if mode not in constants.ITEM_SELECTION_MODE:
        raise InvalidParamError(mode, constants.ITEM_SELECTION_MODE)
    return self.collidingItems(constants.ITEM_SELECTION_MODE[mode])

get_cache_mode() -> CacheModeStr

Get the current mode modes as a string.

Returns:

Type	Description
CacheModeStr	cache mode

Source code in prettyqt\widgets\graphicsitem.py

def get_cache_mode(self) -> CacheModeStr:
    """Get the current mode modes as a string.

    Returns:
        cache mode
    """
    return CACHE_MODE.inverse[self.cacheMode()]

get_panel_modality() -> PanelModalityStr

Get the current modality modes as a string.

Returns:

Type	Description
PanelModalityStr	panel modality

Source code in prettyqt\widgets\graphicsitem.py

def get_panel_modality(self) -> PanelModalityStr:
    """Get the current modality modes as a string.

    Returns:
        panel modality
    """
    return PANEL_MODALITY.inverse[self.panelModality()]

get_shape() -> gui.PainterPath

Source code in prettyqt\widgets\graphicsitem.py

def get_shape(self) -> gui.PainterPath:
    return gui.PainterPath(self.shape())

set_cache_mode(mode: CacheModeStr) -> None

Set cache mode.

Parameters:

Name	Type	Description	Default
mode	CacheModeStr	cache mode	required

Raises:

Type	Description
InvalidParamError	cache mode does not exist

Source code in prettyqt\widgets\graphicsitem.py

def set_cache_mode(self, mode: CacheModeStr) -> None:
    """Set cache mode.

    Args:
        mode: cache mode

    Raises:
        InvalidParamError: cache mode does not exist
    """
    if mode not in CACHE_MODE:
        raise InvalidParamError(mode, CACHE_MODE)
    self.setCacheMode(CACHE_MODE[mode])

set_focus(reason: constants.FocusReasonStr = 'other')

Source code in prettyqt\widgets\graphicsitem.py

def set_focus(self, reason: constants.FocusReasonStr = "other"):
    if reason not in constants.FOCUS_REASONS:
        raise InvalidParamError(reason, constants.FOCUS_REASONS)
    self.setFocus(constants.FOCUS_REASONS[reason])

set_panel_modality(modality: PanelModalityStr) -> None

Set panel modality.

Parameters:

Name	Type	Description	Default
modality	PanelModalityStr	panel modality	required

Raises:

Type	Description
InvalidParamError	panel modality does not exist

Source code in prettyqt\widgets\graphicsitem.py

def set_panel_modality(self, modality: PanelModalityStr) -> None:
    """Set panel modality.

    Args:
        modality: panel modality

    Raises:
        InvalidParamError: panel modality does not exist
    """
    if modality not in PANEL_MODALITY:
        raise InvalidParamError(modality, PANEL_MODALITY)
    self.setPanelModality(PANEL_MODALITY[modality])

set_scale(scale: tuple[float, float] | float)

Source code in prettyqt\widgets\graphicsitem.py

def set_scale(self, scale: tuple[float, float] | float):
    if isinstance(scale, float):
        self.setScale(scale)
    else:
        self.setTransform(gui.Transform.fromScale(scale[0], scale[1]), True)

set_transform(transform: datatypes.TransformType, combine: bool = False)

Source code in prettyqt\widgets\graphicsitem.py

def set_transform(self, transform: datatypes.TransformType, combine: bool = False):
    if isinstance(transform, tuple):
        transform = gui.Transform(*transform)
    self.setTransform(transform, combine)

GraphicsLayout

Bases: GraphicsLayoutMixin, QtWidgets.QGraphicsLayout

Source code in prettyqt\widgets\graphicslayout.py

class GraphicsLayout(GraphicsLayoutMixin, QtWidgets.QGraphicsLayout):
    pass

GraphicsLayoutItem

Bases: GraphicsLayoutItemMixin, QtWidgets.QGraphicsLayoutItem

Source code in prettyqt\widgets\graphicslayoutitem.py

class GraphicsLayoutItem(GraphicsLayoutItemMixin, QtWidgets.QGraphicsLayoutItem):
    pass

GraphicsLayoutItemMixin

Source code in prettyqt\widgets\graphicslayoutitem.py

class GraphicsLayoutItemMixin:
    def __repr__(self):
        return get_repr(self)

    def __bool__(self):
        return not self.isEmpty()

    @functools.singledispatchmethod
    def set_size_policy(
        self,
        horizontal: widgets.sizepolicy.SizePolicyStr,
        vertical: widgets.sizepolicy.SizePolicyStr,
        control_type: widgets.sizepolicy.ControlTypeStr = "default",
    ):
        """Set the size policy.

        Args:
            horizontal: horizontal size policy
            vertical: vertical size policy
            control_type: control type associated with the widget
        """
        h_policy = widgets.sizepolicy.SIZE_POLICY[horizontal]
        v_policy = widgets.sizepolicy.SIZE_POLICY[vertical]
        c = widgets.sizepolicy.CONTROL_TYPE[control_type]
        self.setSizePolicy(h_policy, v_policy, c)

    @set_size_policy.register
    def _(self, policy: QtWidgets.QSizePolicy):
        self.setSizePolicy(policy)

    def get_size_policy(self) -> widgets.SizePolicy:
        qpol = self.sizePolicy()
        return widgets.SizePolicy.clone(qpol)

_(policy: QtWidgets.QSizePolicy)

Source code in prettyqt\widgets\graphicslayoutitem.py

@set_size_policy.register
def _(self, policy: QtWidgets.QSizePolicy):
    self.setSizePolicy(policy)

__bool__()

Source code in prettyqt\widgets\graphicslayoutitem.py

def __bool__(self):
    return not self.isEmpty()

__repr__()

Source code in prettyqt\widgets\graphicslayoutitem.py

def __repr__(self):
    return get_repr(self)

get_size_policy() -> widgets.SizePolicy

Source code in prettyqt\widgets\graphicslayoutitem.py

def get_size_policy(self) -> widgets.SizePolicy:
    qpol = self.sizePolicy()
    return widgets.SizePolicy.clone(qpol)

set_size_policy(horizontal: widgets.sizepolicy.SizePolicyStr, vertical: widgets.sizepolicy.SizePolicyStr, control_type: widgets.sizepolicy.ControlTypeStr = 'default')

Set the size policy.

Parameters:

Name	Type	Description	Default
horizontal	widgets.sizepolicy.SizePolicyStr	horizontal size policy	required
vertical	widgets.sizepolicy.SizePolicyStr	vertical size policy	required
control_type	widgets.sizepolicy.ControlTypeStr	control type associated with the widget	'default'

Source code in prettyqt\widgets\graphicslayoutitem.py

@functools.singledispatchmethod
def set_size_policy(
    self,
    horizontal: widgets.sizepolicy.SizePolicyStr,
    vertical: widgets.sizepolicy.SizePolicyStr,
    control_type: widgets.sizepolicy.ControlTypeStr = "default",
):
    """Set the size policy.

    Args:
        horizontal: horizontal size policy
        vertical: vertical size policy
        control_type: control type associated with the widget
    """
    h_policy = widgets.sizepolicy.SIZE_POLICY[horizontal]
    v_policy = widgets.sizepolicy.SIZE_POLICY[vertical]
    c = widgets.sizepolicy.CONTROL_TYPE[control_type]
    self.setSizePolicy(h_policy, v_policy, c)

GraphicsLayoutMixin

Bases: widgets.GraphicsLayoutItemMixin

Source code in prettyqt\widgets\graphicslayout.py

class GraphicsLayoutMixin(widgets.GraphicsLayoutItemMixin):
    def __getitem__(self, index: int) -> QtWidgets.QGraphicsItem:
        layoutitem = self.itemAt(index)
        return layoutitem.graphicsItem()

    def __setitem__(self, index: int, value: QtWidgets.QGraphicsItem):
        layoutitem = self.itemAt(index)
        layoutitem.setGraphicsItem(value)

    def __delitem__(self, index: int):
        self.removeAt(index)

    def __iter__(self) -> Iterator[QtWidgets.QGraphicsItem]:
        return iter(self[i] for i in range(self.count()))

    def __contains__(self, item):
        return item in self.get_children()

    def __len__(self):
        # for PySide2
        return self.count()

    def get_children(self) -> list[QtWidgets.QGraphicsItem]:
        return list(self)

    def set_margin(self, margin: int):
        self.setContentsMargins(margin, margin, margin, margin)

__contains__(item)

Source code in prettyqt\widgets\graphicslayout.py

def __contains__(self, item):
    return item in self.get_children()

__delitem__(index: int)

Source code in prettyqt\widgets\graphicslayout.py

def __delitem__(self, index: int):
    self.removeAt(index)

__getitem__(index: int) -> QtWidgets.QGraphicsItem

Source code in prettyqt\widgets\graphicslayout.py

def __getitem__(self, index: int) -> QtWidgets.QGraphicsItem:
    layoutitem = self.itemAt(index)
    return layoutitem.graphicsItem()

__iter__() -> Iterator[QtWidgets.QGraphicsItem]

Source code in prettyqt\widgets\graphicslayout.py

def __iter__(self) -> Iterator[QtWidgets.QGraphicsItem]:
    return iter(self[i] for i in range(self.count()))

__len__()

Source code in prettyqt\widgets\graphicslayout.py

def __len__(self):
    # for PySide2
    return self.count()

__setitem__(index: int, value: QtWidgets.QGraphicsItem)

Source code in prettyqt\widgets\graphicslayout.py

def __setitem__(self, index: int, value: QtWidgets.QGraphicsItem):
    layoutitem = self.itemAt(index)
    layoutitem.setGraphicsItem(value)

get_children() -> list[QtWidgets.QGraphicsItem]

Source code in prettyqt\widgets\graphicslayout.py

def get_children(self) -> list[QtWidgets.QGraphicsItem]:
    return list(self)

set_margin(margin: int)

Source code in prettyqt\widgets\graphicslayout.py

def set_margin(self, margin: int):
    self.setContentsMargins(margin, margin, margin, margin)

GraphicsLineItem

Bases: widgets.GraphicsItemMixin, QtWidgets.QGraphicsLineItem

Source code in prettyqt\widgets\graphicslineitem.py

class GraphicsLineItem(widgets.GraphicsItemMixin, QtWidgets.QGraphicsLineItem):
    def __repr__(self):
        return get_repr(self, self.get_line())

    def get_line(self) -> core.LineF:
        return core.LineF(self.line())

__repr__()

Source code in prettyqt\widgets\graphicslineitem.py

def __repr__(self):
    return get_repr(self, self.get_line())

get_line() -> core.LineF

Source code in prettyqt\widgets\graphicslineitem.py

def get_line(self) -> core.LineF:
    return core.LineF(self.line())

GraphicsLinearLayout

Bases: widgets.GraphicsLayoutMixin, QtWidgets.QGraphicsLinearLayout

Source code in prettyqt\widgets\graphicslinearlayout.py

class GraphicsLinearLayout(widgets.GraphicsLayoutMixin, QtWidgets.QGraphicsLinearLayout):
    def __init__(
        self,
        orientation: (constants.OrientationStr | QtCore.Qt.Orientation) = "horizontal",
        parent: QtWidgets.QGraphicsLayoutItem | None = None,
    ):
        if isinstance(orientation, QtCore.Qt.Orientation):
            ori = orientation
        else:
            ori = constants.ORIENTATION[orientation]
        super().__init__(ori, parent)

    # def serialize_fields(self):
    #     return dict(items=self.get_children())

    # def __setstate__(self, state):
    #     for item, pos in zip(state["widgets"], state["positions"]):
    #         x, y = pos
    #         self[x, y] = item

    # def __reduce__(self):
    #     return type(self), (), self.__getstate__()

    def __add__(self, other):
        self[self.count()] = other
        return self

__add__(other)

Source code in prettyqt\widgets\graphicslinearlayout.py

def __add__(self, other):
    self[self.count()] = other
    return self

__init__(orientation: constants.OrientationStr | QtCore.Qt.Orientation = 'horizontal', parent: QtWidgets.QGraphicsLayoutItem | None = None)

Source code in prettyqt\widgets\graphicslinearlayout.py

def __init__(
    self,
    orientation: (constants.OrientationStr | QtCore.Qt.Orientation) = "horizontal",
    parent: QtWidgets.QGraphicsLayoutItem | None = None,
):
    if isinstance(orientation, QtCore.Qt.Orientation):
        ori = orientation
    else:
        ori = constants.ORIENTATION[orientation]
    super().__init__(ori, parent)

GraphicsObject

Bases: GraphicsObjectMixin, QtWidgets.QGraphicsObject

Source code in prettyqt\widgets\graphicsobject.py

class GraphicsObject(GraphicsObjectMixin, QtWidgets.QGraphicsObject):
    pass

GraphicsObjectMixin

Bases: core.ObjectMixin, widgets.GraphicsItemMixin

Source code in prettyqt\widgets\graphicsobject.py

class GraphicsObjectMixin(core.ObjectMixin, widgets.GraphicsItemMixin):
    pass

GraphicsOpacityEffect

Bases: widgets.GraphicsEffectMixin, QtWidgets.QGraphicsOpacityEffect

Source code in prettyqt\widgets\graphicsopacityeffect.py

class GraphicsOpacityEffect(
    widgets.GraphicsEffectMixin, QtWidgets.QGraphicsOpacityEffect
):
    def get_opacity_mask(self) -> gui.Brush:
        return gui.Brush(self.opacityMask())

get_opacity_mask() -> gui.Brush

Source code in prettyqt\widgets\graphicsopacityeffect.py

def get_opacity_mask(self) -> gui.Brush:
    return gui.Brush(self.opacityMask())

GraphicsPathItem

Bases: widgets.AbstractGraphicsShapeItemMixin, QtWidgets.QGraphicsPathItem

Source code in prettyqt\widgets\graphicspathitem.py

class GraphicsPathItem(
    widgets.AbstractGraphicsShapeItemMixin, QtWidgets.QGraphicsPathItem
):
    pass

GraphicsPixmapItem

Bases: widgets.GraphicsItemMixin, QtWidgets.QGraphicsPixmapItem

Source code in prettyqt\widgets\graphicspixmapitem.py

class GraphicsPixmapItem(widgets.GraphicsItemMixin, QtWidgets.QGraphicsPixmapItem):
    def set_transformation_mode(self, mode: constants.TransformationModeStr):
        """Set transformation mode.

        Args:
            mode: transformation mode to use

        Raises:
            InvalidParamError: mode does not exist
        """
        if mode not in constants.TRANSFORMATION_MODE:
            raise InvalidParamError(mode, constants.TRANSFORMATION_MODE)
        self.setTransformationMode(constants.TRANSFORMATION_MODE[mode])

    def get_transformation_mode(self) -> constants.TransformationModeStr:
        """Return current transformation mode.

        Returns:
            transformation mode
        """
        return constants.TRANSFORMATION_MODE.inverse[self.transformationMode()]

    def set_shape_mode(self, mode: ShapeModeStr):
        """Set shape mode.

        Args:
            mode: shape mode to use

        Raises:
            InvalidParamError: mode does not exist
        """
        if mode not in SHAPE_MODE:
            raise InvalidParamError(mode, SHAPE_MODE)
        self.setShapeMode(SHAPE_MODE[mode])

    def get_shape_mode(self) -> ShapeModeStr:
        """Return current shape mode.

        Returns:
            shape mode
        """
        return SHAPE_MODE.inverse[self.shapeMode()]

    def get_pixmap(self) -> gui.Pixmap | None:
        pix = self.pixmap()
        return None if pix.isNull() else gui.Pixmap(pix)

get_pixmap() -> gui.Pixmap | None

Source code in prettyqt\widgets\graphicspixmapitem.py

def get_pixmap(self) -> gui.Pixmap | None:
    pix = self.pixmap()
    return None if pix.isNull() else gui.Pixmap(pix)

get_shape_mode() -> ShapeModeStr

Return current shape mode.

Returns:

Type	Description
ShapeModeStr	shape mode

Source code in prettyqt\widgets\graphicspixmapitem.py

def get_shape_mode(self) -> ShapeModeStr:
    """Return current shape mode.

    Returns:
        shape mode
    """
    return SHAPE_MODE.inverse[self.shapeMode()]

get_transformation_mode() -> constants.TransformationModeStr

Return current transformation mode.

Returns:

Type	Description
constants.TransformationModeStr	transformation mode

Source code in prettyqt\widgets\graphicspixmapitem.py

def get_transformation_mode(self) -> constants.TransformationModeStr:
    """Return current transformation mode.

    Returns:
        transformation mode
    """
    return constants.TRANSFORMATION_MODE.inverse[self.transformationMode()]

set_shape_mode(mode: ShapeModeStr)

Set shape mode.

Parameters:

Name	Type	Description	Default
mode	ShapeModeStr	shape mode to use	required

Raises:

Type	Description
InvalidParamError	mode does not exist

Source code in prettyqt\widgets\graphicspixmapitem.py

def set_shape_mode(self, mode: ShapeModeStr):
    """Set shape mode.

    Args:
        mode: shape mode to use

    Raises:
        InvalidParamError: mode does not exist
    """
    if mode not in SHAPE_MODE:
        raise InvalidParamError(mode, SHAPE_MODE)
    self.setShapeMode(SHAPE_MODE[mode])

set_transformation_mode(mode: constants.TransformationModeStr)

Set transformation mode.

Parameters:

Name	Type	Description	Default
mode	constants.TransformationModeStr	transformation mode to use	required

Raises:

Type	Description
InvalidParamError	mode does not exist

Source code in prettyqt\widgets\graphicspixmapitem.py

def set_transformation_mode(self, mode: constants.TransformationModeStr):
    """Set transformation mode.

    Args:
        mode: transformation mode to use

    Raises:
        InvalidParamError: mode does not exist
    """
    if mode not in constants.TRANSFORMATION_MODE:
        raise InvalidParamError(mode, constants.TRANSFORMATION_MODE)
    self.setTransformationMode(constants.TRANSFORMATION_MODE[mode])

GraphicsPolygonItem

Bases: widgets.AbstractGraphicsShapeItemMixin, QtWidgets.QGraphicsPolygonItem

Source code in prettyqt\widgets\graphicspolygonitem.py

class GraphicsPolygonItem(
    widgets.AbstractGraphicsShapeItemMixin, QtWidgets.QGraphicsPolygonItem
):
    def serialize_fields(self):
        return dict(polygon=self.get_polygon(), fill_rule=self.get_fill_rule())

    def get_polygon(self) -> gui.PolygonF:
        return gui.PolygonF(self.polygon())

    def set_fill_rule(self, rule: constants.FillRuleStr):
        if rule not in constants.FILL_RULE:
            raise InvalidParamError(rule, constants.FILL_RULE)
        self.setFillRule(constants.FILL_RULE[rule])

    def get_fill_rule(self) -> constants.FillRuleStr:
        return constants.FILL_RULE.inverse[self.fillRule()]

get_fill_rule() -> constants.FillRuleStr

Source code in prettyqt\widgets\graphicspolygonitem.py

def get_fill_rule(self) -> constants.FillRuleStr:
    return constants.FILL_RULE.inverse[self.fillRule()]

get_polygon() -> gui.PolygonF

Source code in prettyqt\widgets\graphicspolygonitem.py

def get_polygon(self) -> gui.PolygonF:
    return gui.PolygonF(self.polygon())

serialize_fields()

Source code in prettyqt\widgets\graphicspolygonitem.py

def serialize_fields(self):
    return dict(polygon=self.get_polygon(), fill_rule=self.get_fill_rule())

set_fill_rule(rule: constants.FillRuleStr)

Source code in prettyqt\widgets\graphicspolygonitem.py

def set_fill_rule(self, rule: constants.FillRuleStr):
    if rule not in constants.FILL_RULE:
        raise InvalidParamError(rule, constants.FILL_RULE)
    self.setFillRule(constants.FILL_RULE[rule])

GraphicsProxyWidget

Bases: widgets.GraphicsWidgetMixin, QtWidgets.QGraphicsProxyWidget

Source code in prettyqt\widgets\graphicsproxywidget.py

class GraphicsProxyWidget(widgets.GraphicsWidgetMixin, QtWidgets.QGraphicsProxyWidget):
    pass

GraphicsRectItem

Bases: widgets.AbstractGraphicsShapeItemMixin, QtWidgets.QGraphicsRectItem

Source code in prettyqt\widgets\graphicsrectitem.py

class GraphicsRectItem(
    widgets.AbstractGraphicsShapeItemMixin, QtWidgets.QGraphicsRectItem
):
    def __repr__(self):
        return get_repr(self, self.get_rect())

    def get_rect(self):
        return core.RectF(self.rect())

    def serialize_fields(self):
        return dict(rect=self.get_rect())

    def __setstate__(self, state):
        super().__setstate__(state)
        self.setRect(state["rect"])

__repr__()

Source code in prettyqt\widgets\graphicsrectitem.py

def __repr__(self):
    return get_repr(self, self.get_rect())

__setstate__(state)

Source code in prettyqt\widgets\graphicsrectitem.py

def __setstate__(self, state):
    super().__setstate__(state)
    self.setRect(state["rect"])

get_rect()

Source code in prettyqt\widgets\graphicsrectitem.py

def get_rect(self):
    return core.RectF(self.rect())

serialize_fields()

Source code in prettyqt\widgets\graphicsrectitem.py

def serialize_fields(self):
    return dict(rect=self.get_rect())

GraphicsRotation

Bases: widgets.GraphicsTransformMixin, QtWidgets.QGraphicsRotation

Source code in prettyqt\widgets\graphicsrotation.py

class GraphicsRotation(widgets.GraphicsTransformMixin, QtWidgets.QGraphicsRotation):
    def set_axis(self, axis: constants.AxisStr):
        if axis not in constants.AXIS:
            raise InvalidParamError(axis, constants.AXIS)
        self.setAxis(constants.AXIS[axis])

    def set_origin(self, origin: datatypes.VectorType):
        if not isinstance(origin, QtGui.QVector3D):
            origin = QtGui.QVector3D(*origin)
        self.setOrigin(origin)

set_axis(axis: constants.AxisStr)

Source code in prettyqt\widgets\graphicsrotation.py

def set_axis(self, axis: constants.AxisStr):
    if axis not in constants.AXIS:
        raise InvalidParamError(axis, constants.AXIS)
    self.setAxis(constants.AXIS[axis])

set_origin(origin: datatypes.VectorType)

Source code in prettyqt\widgets\graphicsrotation.py

def set_origin(self, origin: datatypes.VectorType):
    if not isinstance(origin, QtGui.QVector3D):
        origin = QtGui.QVector3D(*origin)
    self.setOrigin(origin)

GraphicsScale

Bases: widgets.GraphicsTransformMixin, QtWidgets.QGraphicsScale

Source code in prettyqt\widgets\graphicsscale.py

class GraphicsScale(widgets.GraphicsTransformMixin, QtWidgets.QGraphicsScale):
    def set_origin(self, origin: datatypes.VectorType):
        if not isinstance(origin, QtGui.QVector3D):
            origin = QtGui.QVector3D(*origin)
        self.setOrigin(origin)

set_origin(origin: datatypes.VectorType)

Source code in prettyqt\widgets\graphicsscale.py

def set_origin(self, origin: datatypes.VectorType):
    if not isinstance(origin, QtGui.QVector3D):
        origin = QtGui.QVector3D(*origin)
    self.setOrigin(origin)

GraphicsScene

Bases: core.ObjectMixin, QtWidgets.QGraphicsScene

Source code in prettyqt\widgets\graphicsscene.py

class GraphicsScene(core.ObjectMixin, QtWidgets.QGraphicsScene):
    def serialize_fields(self):
        return dict(
            items=self.items(),
            background_brush=self.get_background_brush(),
            foreground_brush=self.get_foreground_brush(),
            item_index_method=self.get_item_index_method(),
            minimum_render_size=self.minimumRenderSize(),
            palette=self.get_palette(),
            bsp_tree_depth=self.bspTreeDepth(),
            focus_on_touch=self.focusOnTouch(),
            sticky_focus=self.stickyFocus(),
            scene_rect=core.RectF(self.sceneRect()),
            font=self.get_font(),
        )

    def __setitem__(self, state):
        # self.setItem
        self.setBackgroundBrush(state["background_brush"])
        self.setForegroundBrush(state["foreground_brush"])
        self.set_item_index_method(state["item_index_method"])
        self.setMinimumRenderSize(state["minimum_render_size"])
        self.setPalette(state["palette"])
        self.setBspTreeDepth(state["bsp_tree_depth"])
        self.setFocusOnTouchRelease(state["focus_on_touch"])
        self.setStickyFocus(state["focus_on_touch"])
        self.setSceneRect(state["scene_rect"])
        self.setFont(state["font"])

    def __getitem__(self, index: int) -> QtWidgets.QGraphicsItem:
        return self.items()[index]

    def get_palette(self) -> gui.Palette:
        return gui.Palette(self.palette())

    def get_font(self) -> gui.Font:
        return gui.Font(self.font())

    def get_background_brush(self) -> gui.Brush:
        return gui.Brush(self.backgroundBrush())

    def get_foreground_brush(self) -> gui.Brush:
        return gui.Brush(self.foregroundBrush())

    def add(self, item) -> QtWidgets.QGraphicsItem:
        match item:
            case QtWidgets.QGraphicsItem():
                self.addItem(item)
                return item
            case QtGui.QPixmap():
                return self.add_pixmap(item)
            case QtGui.QPainterPath():
                return self.add_path(item)
            case QtGui.QPolygonF():
                return self.add_polygon(item)
            case QtCore.QRectF():
                return self.add_rect(item)
            case QtCore.QLine():
                return self.add_line(item)
            case str():
                return self.add_text(item)
            case QtWidgets.QWidget():
                return self.add_widget(item)
            case _:
                raise TypeError(item)

    def add_pixmap(self, pixmap: QtGui.QPixmap) -> widgets.GraphicsPixmapItem:
        g_item = widgets.GraphicsPixmapItem()
        g_item.setPixmap(pixmap)
        self.addItem(g_item)
        return g_item

    def add_polygon(
        self,
        polygon: QtGui.QPolygonF | QtGui.QPolygon,
        pen: QtGui.QPen | None = None,
        brush: QtGui.QBrush | None = None,
    ) -> widgets.GraphicsPolygonItem:
        if isinstance(polygon, QtGui.QPolygon):
            polygon = gui.PolygonF(polygon)
        g_item = widgets.GraphicsPolygonItem()
        g_item.setPolygon(polygon)
        if brush is not None:
            g_item.setBrush(brush)
        if pen is not None:
            g_item.setPen(pen)
        self.addItem(g_item)
        return g_item

    def add_path(
        self,
        path: QtGui.QPainterPath,
        pen: QtGui.QPen | None = None,
        brush: QtGui.QBrush | None = None,
    ) -> widgets.GraphicsPathItem:
        g_item = widgets.GraphicsPathItem()
        g_item.setPath(path)
        if brush is not None:
            g_item.setBrush(brush)
        if pen is not None:
            g_item.setPen(pen)
        self.addItem(g_item)
        return g_item

    def add_rect(
        self,
        rect: datatypes.RectType | datatypes.RectFType,
        pen: QtGui.QPen | None = None,
        brush: QtGui.QBrush | None = None,
    ) -> widgets.GraphicsRectItem:
        if isinstance(rect, QtCore.QRect):
            rect = core.RectF(rect)
        elif isinstance(rect, tuple):
            rect = core.RectF(*rect)
        g_item = widgets.GraphicsRectItem()
        g_item.setRect(rect)
        if brush is not None:
            g_item.setBrush(brush)
        if pen is not None:
            g_item.setPen(pen)
        self.addItem(g_item)
        return g_item

    def add_line(
        self,
        line: QtCore.QLineF | QtCore.QLine | tuple[float, float, float, float],
        pen: QtGui.QPen | None = None,
    ) -> widgets.GraphicsLineItem:
        if isinstance(line, QtCore.QLine):
            line = core.LineF(line)
        elif isinstance(line, tuple):
            line = core.LineF(*line)
        g_item = widgets.GraphicsLineItem()
        g_item.setLine(line)
        if pen is not None:
            g_item.setPen(pen)
        self.addItem(g_item)
        return g_item

    def add_ellipse(
        self,
        ellipse: datatypes.RectType | datatypes.RectFType,
        pen: QtGui.QPen | None = None,
        brush: QtGui.QBrush | None = None,
    ) -> widgets.GraphicsEllipseItem:
        if isinstance(ellipse, QtCore.QRect):
            ellipse = core.RectF(ellipse)
        elif isinstance(ellipse, tuple):
            ellipse = core.RectF(*ellipse)
        g_item = widgets.GraphicsEllipseItem()
        g_item.setRect(ellipse)
        if brush is not None:
            g_item.setBrush(brush)
        if pen is not None:
            g_item.setPen(pen)
        self.addItem(g_item)
        return g_item

    def add_text(
        self, text: str, font: QtGui.QFont | None = None
    ) -> widgets.GraphicsTextItem:
        g_item = widgets.GraphicsTextItem()
        g_item.setPlainText(text)
        if font is not None:
            g_item.setFont(font)
        self.addItem(g_item)
        return g_item

    def add_simple_text(
        self, text: str, font: QtGui.QFont | None = None
    ) -> widgets.GraphicsSimpleTextItem:
        g_item = widgets.GraphicsSimpleTextItem()
        g_item.setText(text)
        if font is not None:
            g_item.setFont(font)
        self.addItem(g_item)
        return g_item

    def add_widget(self, widget: QtWidgets.QWidget) -> widgets.GraphicsProxyWidget:
        g_item = widgets.GraphicsProxyWidget()
        g_item.setWidget(widget)
        self.addItem(g_item)
        return g_item

    def colliding_items(
        self,
        item: QtWidgets.QGraphicsItem,
        mode: constants.ItemSelectionModeStr = "intersects_shape",
    ) -> list[QtWidgets.QGraphicsItem]:
        if mode not in constants.ITEM_SELECTION_MODE:
            raise InvalidParamError(mode, constants.ITEM_SELECTION_MODE)
        return self.collidingItems(item, constants.ITEM_SELECTION_MODE[mode])

    def add_item_group(
        self, *items: QtWidgets.QGraphicsItem
    ) -> widgets.GraphicsItemGroup:
        group = widgets.GraphicsItemGroup()
        for item in items:
            group.addToGroup(item)
        return group

    def set_item_index_method(self, method: ItemIndexMethodStr):
        """Set item index method.

        Args:
            method: item index method to use

        Raises:
            InvalidParamError: invalid item index method
        """
        if method not in ITEM_INDEX_METHOD:
            raise InvalidParamError(method, ITEM_INDEX_METHOD)
        self.setItemIndexMethod(ITEM_INDEX_METHOD[method])

    def get_item_index_method(self) -> ItemIndexMethodStr:
        """Return item index method.

        Returns:
            item index method
        """
        return ITEM_INDEX_METHOD.inverse[self.itemIndexMethod()]

__getitem__(index: int) -> QtWidgets.QGraphicsItem

Source code in prettyqt\widgets\graphicsscene.py

def __getitem__(self, index: int) -> QtWidgets.QGraphicsItem:
    return self.items()[index]

__setitem__(state)

Source code in prettyqt\widgets\graphicsscene.py

def __setitem__(self, state):
    # self.setItem
    self.setBackgroundBrush(state["background_brush"])
    self.setForegroundBrush(state["foreground_brush"])
    self.set_item_index_method(state["item_index_method"])
    self.setMinimumRenderSize(state["minimum_render_size"])
    self.setPalette(state["palette"])
    self.setBspTreeDepth(state["bsp_tree_depth"])
    self.setFocusOnTouchRelease(state["focus_on_touch"])
    self.setStickyFocus(state["focus_on_touch"])
    self.setSceneRect(state["scene_rect"])
    self.setFont(state["font"])

add(item) -> QtWidgets.QGraphicsItem

Source code in prettyqt\widgets\graphicsscene.py

def add(self, item) -> QtWidgets.QGraphicsItem:
    match item:
        case QtWidgets.QGraphicsItem():
            self.addItem(item)
            return item
        case QtGui.QPixmap():
            return self.add_pixmap(item)
        case QtGui.QPainterPath():
            return self.add_path(item)
        case QtGui.QPolygonF():
            return self.add_polygon(item)
        case QtCore.QRectF():
            return self.add_rect(item)
        case QtCore.QLine():
            return self.add_line(item)
        case str():
            return self.add_text(item)
        case QtWidgets.QWidget():
            return self.add_widget(item)
        case _:
            raise TypeError(item)

add_ellipse(ellipse: datatypes.RectType | datatypes.RectFType, pen: QtGui.QPen | None = None, brush: QtGui.QBrush | None = None) -> widgets.GraphicsEllipseItem

Source code in prettyqt\widgets\graphicsscene.py

def add_ellipse(
    self,
    ellipse: datatypes.RectType | datatypes.RectFType,
    pen: QtGui.QPen | None = None,
    brush: QtGui.QBrush | None = None,
) -> widgets.GraphicsEllipseItem:
    if isinstance(ellipse, QtCore.QRect):
        ellipse = core.RectF(ellipse)
    elif isinstance(ellipse, tuple):
        ellipse = core.RectF(*ellipse)
    g_item = widgets.GraphicsEllipseItem()
    g_item.setRect(ellipse)
    if brush is not None:
        g_item.setBrush(brush)
    if pen is not None:
        g_item.setPen(pen)
    self.addItem(g_item)
    return g_item

add_item_group(*items: QtWidgets.QGraphicsItem) -> widgets.GraphicsItemGroup

Source code in prettyqt\widgets\graphicsscene.py

def add_item_group(
    self, *items: QtWidgets.QGraphicsItem
) -> widgets.GraphicsItemGroup:
    group = widgets.GraphicsItemGroup()
    for item in items:
        group.addToGroup(item)
    return group

add_line(line: QtCore.QLineF | QtCore.QLine | tuple[float, float, float, float], pen: QtGui.QPen | None = None) -> widgets.GraphicsLineItem

Source code in prettyqt\widgets\graphicsscene.py

def add_line(
    self,
    line: QtCore.QLineF | QtCore.QLine | tuple[float, float, float, float],
    pen: QtGui.QPen | None = None,
) -> widgets.GraphicsLineItem:
    if isinstance(line, QtCore.QLine):
        line = core.LineF(line)
    elif isinstance(line, tuple):
        line = core.LineF(*line)
    g_item = widgets.GraphicsLineItem()
    g_item.setLine(line)
    if pen is not None:
        g_item.setPen(pen)
    self.addItem(g_item)
    return g_item

add_path(path: QtGui.QPainterPath, pen: QtGui.QPen | None = None, brush: QtGui.QBrush | None = None) -> widgets.GraphicsPathItem

Source code in prettyqt\widgets\graphicsscene.py

def add_path(
    self,
    path: QtGui.QPainterPath,
    pen: QtGui.QPen | None = None,
    brush: QtGui.QBrush | None = None,
) -> widgets.GraphicsPathItem:
    g_item = widgets.GraphicsPathItem()
    g_item.setPath(path)
    if brush is not None:
        g_item.setBrush(brush)
    if pen is not None:
        g_item.setPen(pen)
    self.addItem(g_item)
    return g_item

add_pixmap(pixmap: QtGui.QPixmap) -> widgets.GraphicsPixmapItem

Source code in prettyqt\widgets\graphicsscene.py

def add_pixmap(self, pixmap: QtGui.QPixmap) -> widgets.GraphicsPixmapItem:
    g_item = widgets.GraphicsPixmapItem()
    g_item.setPixmap(pixmap)
    self.addItem(g_item)
    return g_item

add_polygon(polygon: QtGui.QPolygonF | QtGui.QPolygon, pen: QtGui.QPen | None = None, brush: QtGui.QBrush | None = None) -> widgets.GraphicsPolygonItem

Source code in prettyqt\widgets\graphicsscene.py

def add_polygon(
    self,
    polygon: QtGui.QPolygonF | QtGui.QPolygon,
    pen: QtGui.QPen | None = None,
    brush: QtGui.QBrush | None = None,
) -> widgets.GraphicsPolygonItem:
    if isinstance(polygon, QtGui.QPolygon):
        polygon = gui.PolygonF(polygon)
    g_item = widgets.GraphicsPolygonItem()
    g_item.setPolygon(polygon)
    if brush is not None:
        g_item.setBrush(brush)
    if pen is not None:
        g_item.setPen(pen)
    self.addItem(g_item)
    return g_item

add_rect(rect: datatypes.RectType | datatypes.RectFType, pen: QtGui.QPen | None = None, brush: QtGui.QBrush | None = None) -> widgets.GraphicsRectItem

Source code in prettyqt\widgets\graphicsscene.py

def add_rect(
    self,
    rect: datatypes.RectType | datatypes.RectFType,
    pen: QtGui.QPen | None = None,
    brush: QtGui.QBrush | None = None,
) -> widgets.GraphicsRectItem:
    if isinstance(rect, QtCore.QRect):
        rect = core.RectF(rect)
    elif isinstance(rect, tuple):
        rect = core.RectF(*rect)
    g_item = widgets.GraphicsRectItem()
    g_item.setRect(rect)
    if brush is not None:
        g_item.setBrush(brush)
    if pen is not None:
        g_item.setPen(pen)
    self.addItem(g_item)
    return g_item

add_simple_text(text: str, font: QtGui.QFont | None = None) -> widgets.GraphicsSimpleTextItem

Source code in prettyqt\widgets\graphicsscene.py

def add_simple_text(
    self, text: str, font: QtGui.QFont | None = None
) -> widgets.GraphicsSimpleTextItem:
    g_item = widgets.GraphicsSimpleTextItem()
    g_item.setText(text)
    if font is not None:
        g_item.setFont(font)
    self.addItem(g_item)
    return g_item

add_text(text: str, font: QtGui.QFont | None = None) -> widgets.GraphicsTextItem

Source code in prettyqt\widgets\graphicsscene.py

def add_text(
    self, text: str, font: QtGui.QFont | None = None
) -> widgets.GraphicsTextItem:
    g_item = widgets.GraphicsTextItem()
    g_item.setPlainText(text)
    if font is not None:
        g_item.setFont(font)
    self.addItem(g_item)
    return g_item

add_widget(widget: QtWidgets.QWidget) -> widgets.GraphicsProxyWidget

Source code in prettyqt\widgets\graphicsscene.py

def add_widget(self, widget: QtWidgets.QWidget) -> widgets.GraphicsProxyWidget:
    g_item = widgets.GraphicsProxyWidget()
    g_item.setWidget(widget)
    self.addItem(g_item)
    return g_item

colliding_items(item: QtWidgets.QGraphicsItem, mode: constants.ItemSelectionModeStr = 'intersects_shape') -> list[QtWidgets.QGraphicsItem]

Source code in prettyqt\widgets\graphicsscene.py

def colliding_items(
    self,
    item: QtWidgets.QGraphicsItem,
    mode: constants.ItemSelectionModeStr = "intersects_shape",
) -> list[QtWidgets.QGraphicsItem]:
    if mode not in constants.ITEM_SELECTION_MODE:
        raise InvalidParamError(mode, constants.ITEM_SELECTION_MODE)
    return self.collidingItems(item, constants.ITEM_SELECTION_MODE[mode])

get_background_brush() -> gui.Brush

Source code in prettyqt\widgets\graphicsscene.py

def get_background_brush(self) -> gui.Brush:
    return gui.Brush(self.backgroundBrush())

get_font() -> gui.Font

Source code in prettyqt\widgets\graphicsscene.py

def get_font(self) -> gui.Font:
    return gui.Font(self.font())

get_foreground_brush() -> gui.Brush

Source code in prettyqt\widgets\graphicsscene.py

def get_foreground_brush(self) -> gui.Brush:
    return gui.Brush(self.foregroundBrush())

get_item_index_method() -> ItemIndexMethodStr

Return item index method.

Returns:

Type	Description
ItemIndexMethodStr	item index method

Source code in prettyqt\widgets\graphicsscene.py

def get_item_index_method(self) -> ItemIndexMethodStr:
    """Return item index method.

    Returns:
        item index method
    """
    return ITEM_INDEX_METHOD.inverse[self.itemIndexMethod()]

get_palette() -> gui.Palette

Source code in prettyqt\widgets\graphicsscene.py

def get_palette(self) -> gui.Palette:
    return gui.Palette(self.palette())

serialize_fields()

Source code in prettyqt\widgets\graphicsscene.py

def serialize_fields(self):
    return dict(
        items=self.items(),
        background_brush=self.get_background_brush(),
        foreground_brush=self.get_foreground_brush(),
        item_index_method=self.get_item_index_method(),
        minimum_render_size=self.minimumRenderSize(),
        palette=self.get_palette(),
        bsp_tree_depth=self.bspTreeDepth(),
        focus_on_touch=self.focusOnTouch(),
        sticky_focus=self.stickyFocus(),
        scene_rect=core.RectF(self.sceneRect()),
        font=self.get_font(),
    )

set_item_index_method(method: ItemIndexMethodStr)

Set item index method.

Parameters:

Name	Type	Description	Default
method	ItemIndexMethodStr	item index method to use	required

Raises:

Type	Description
InvalidParamError	invalid item index method

Source code in prettyqt\widgets\graphicsscene.py

def set_item_index_method(self, method: ItemIndexMethodStr):
    """Set item index method.

    Args:
        method: item index method to use

    Raises:
        InvalidParamError: invalid item index method
    """
    if method not in ITEM_INDEX_METHOD:
        raise InvalidParamError(method, ITEM_INDEX_METHOD)
    self.setItemIndexMethod(ITEM_INDEX_METHOD[method])

GraphicsSimpleTextItem

Bases: widgets.AbstractGraphicsShapeItemMixin, QtWidgets.QGraphicsSimpleTextItem

Source code in prettyqt\widgets\graphicssimpletextitem.py

class GraphicsSimpleTextItem(
    widgets.AbstractGraphicsShapeItemMixin, QtWidgets.QGraphicsSimpleTextItem
):
    def __repr__(self):
        return get_repr(self, self.text())

__repr__()

Source code in prettyqt\widgets\graphicssimpletextitem.py

def __repr__(self):
    return get_repr(self, self.text())

GraphicsTextItem

Bases: widgets.GraphicsObjectMixin, QtWidgets.QGraphicsTextItem

Source code in prettyqt\widgets\graphicstextitem.py

class GraphicsTextItem(widgets.GraphicsObjectMixin, QtWidgets.QGraphicsTextItem):
    def __repr__(self):
        return get_repr(self, self.toPlainText())

__repr__()

Source code in prettyqt\widgets\graphicstextitem.py

def __repr__(self):
    return get_repr(self, self.toPlainText())

GraphicsTransform

Bases: GraphicsTransformMixin, QtWidgets.QGraphicsTransform

Source code in prettyqt\widgets\graphicstransform.py

class GraphicsTransform(GraphicsTransformMixin, QtWidgets.QGraphicsTransform):
    pass

GraphicsTransformMixin

Bases: core.ObjectMixin

Source code in prettyqt\widgets\graphicstransform.py

class GraphicsTransformMixin(core.ObjectMixin):
    pass

GraphicsView

Bases: GraphicsViewMixin, QtWidgets.QGraphicsView

Source code in prettyqt\widgets\graphicsview.py

class GraphicsView(GraphicsViewMixin, QtWidgets.QGraphicsView):
    pass

GraphicsViewMixin

Bases: widgets.AbstractScrollAreaMixin

Source code in prettyqt\widgets\graphicsview.py

class GraphicsViewMixin(widgets.AbstractScrollAreaMixin):
    def serialize_fields(self):
        return dict(
            scene=self.scene(),
            background_brush=self.get_background_brush(),
            foreground_brush=self.get_foreground_brush(),
            transformation_anchor=self.get_transformation_anchor(),
            resize_anchor=self.get_resize_anchor(),
            viewport_update_mode=self.get_viewport_update_mode(),
            drag_mode=self.get_drag_mode(),
            rubberband_selection_mode=self.get_rubberband_selection_mode(),
            scene_rect=core.RectF(self.sceneRect()),
            cache_mode=self.get_cache_mode(),
            is_interactive=self.isInteractive(),
        )

    def __setitem__(self, state):
        super().__setstate__(state)
        self.setScene(state["scene"])
        self.setBackgroundBrush(state["background_brush"])
        self.setForegroundBrush(state["foreground_brush"])
        self.set_transformation_anchor(state["transformation_anchor"])
        self.set_resize_anchor(state["resicze_anchor"])
        self.set_viewport_update_mode(state["viewport_update_mode"])
        self.set_drag_mode(state["drag_mode"])
        self.set_rubberband_selection_mode(state["rubberband_selection_mode"])
        self.setSceneRect(state["scene_rect"])
        self.set_cache_mode(state["cache_mode"])
        self.setInteractive(state["is_interactive"])

    def __getitem__(self, index: int) -> QtWidgets.QGraphicsItem:
        return self.items()[index]

    def get_background_brush(self) -> gui.Brush:
        return gui.Brush(self.backgroundBrush())

    def get_foreground_brush(self) -> gui.Brush:
        return gui.Brush(self.foregroundBrush())

    def invalidate_scene(
        self, rect: QtCore.QRectF, layer: widgets.graphicsscene.SceneLayerStr = "all"
    ):
        if layer not in widgets.graphicsscene.SCENE_LAYER:
            raise InvalidParamError(layer, widgets.graphicsscene.SCENE_LAYER)
        self.invalidateScene(rect, widgets.graphicsscene.SCENE_LAYER[layer])

    def set_transformation_anchor(self, mode: ViewportAnchorStr):
        """Set how the view should position the scene during transformations.

        Args:
            mode: transformation anchor to use

        Raises:
            InvalidParamError: mode does not exist
        """
        if mode not in VIEWPORT_ANCHOR:
            raise InvalidParamError(mode, VIEWPORT_ANCHOR)
        self.setTransformationAnchor(VIEWPORT_ANCHOR[mode])

    def get_transformation_anchor(self) -> ViewportAnchorStr:
        """Return current transformation anchor.

        Returns:
            viewport anchor
        """
        return VIEWPORT_ANCHOR.inverse[self.transformationAnchor()]

    def set_transform(self, transform: datatypes.TransformType, combine: bool = False):
        if isinstance(transform, tuple):
            transform = gui.Transform(*transform)
        self.setTransform(transform, combine)

    def set_resize_anchor(self, mode: ViewportAnchorStr):
        """Set how the view should position the scene during resizes.

        Args:
            mode: resize anchor to use

        Raises:
            InvalidParamError: mode does not exist
        """
        if mode not in VIEWPORT_ANCHOR:
            raise InvalidParamError(mode, VIEWPORT_ANCHOR)
        self.setResizeAnchor(VIEWPORT_ANCHOR[mode])

    def get_resize_anchor(self) -> ViewportAnchorStr:
        """Return current resize anchor.

        Returns:
            resize anchor
        """
        return VIEWPORT_ANCHOR.inverse[self.resizeAnchor()]

    def set_viewport_update_mode(self, mode: ViewportUpdateModeStr):
        """Set how the viewport should update its contents.

        Args:
            mode: viewport update mode to use

        Raises:
            InvalidParamError: mode does not exist
        """
        if mode not in VIEWPORT_UPDATE_MODE:
            raise InvalidParamError(mode, VIEWPORT_UPDATE_MODE)
        self.setViewportUpdateMode(VIEWPORT_UPDATE_MODE[mode])

    def get_viewport_update_mode(self) -> ViewportUpdateModeStr:
        """Return current viewport update mode.

        Returns:
            viewport update mode
        """
        return VIEWPORT_UPDATE_MODE.inverse[self.viewportUpdateMode()]

    def set_drag_mode(self, mode: DragModeStr):
        """Set the behavior for dragging the mouse while the left mouse button is pressed.

        Args:
            mode: drag mode to use

        Raises:
            InvalidParamError: mode does not exist
        """
        if mode not in DRAG_MODE:
            raise InvalidParamError(mode, DRAG_MODE)
        self.setDragMode(DRAG_MODE[mode])

    def get_drag_mode(self) -> DragModeStr:
        """Return current drag mode.

        Returns:
            drag mode
        """
        return DRAG_MODE.inverse[self.dragMode()]

    def set_rubberband_selection_mode(self, mode: constants.ItemSelectionModeStr):
        """Set the behavior for selecting items with a rubber band selection rectangle.

        Args:
            mode: rubberband selection mode to use

        Raises:
            InvalidParamError: mode does not exist
        """
        if mode not in constants.ITEM_SELECTION_MODE:
            raise InvalidParamError(mode, constants.ITEM_SELECTION_MODE)
        self.setRubberBandSelectionMode(constants.ITEM_SELECTION_MODE[mode])

    def get_rubberband_selection_mode(self) -> constants.ItemSelectionModeStr:
        """Return current rubberband selection mode.

        Returns:
            rubberband selection mode
        """
        return constants.ITEM_SELECTION_MODE.inverse[self.rubberBandSelectionMode()]

    def set_cache_mode(self, mode: CacheModeStr):
        """Set the cache mode.

        Args:
            mode: cache mode to use

        Raises:
            InvalidParamError: mode does not exist
        """
        if mode not in CACHE_MODES:
            raise InvalidParamError(mode, CACHE_MODES)
        self.setCacheMode(CACHE_MODES[mode])

    def get_cache_mode(self) -> CacheModeStr:
        """Return current cache mode.

        Returns:
            cache mode
        """
        return CACHE_MODES.inverse[self.cacheMode()]

    def set_optimization_flags(self, *items: OptimizationFlagStr):
        for item in items:
            if item not in OPTIMIZATION_FLAGS:
                raise InvalidParamError(item, OPTIMIZATION_FLAGS)
        flags = helpers.merge_flags(items, OPTIMIZATION_FLAGS)
        self.setOptimizationFlags(flags)

    def get_optimization_flags(self) -> list[OptimizationFlagStr]:
        return OPTIMIZATION_FLAGS.get_list(self.optimizationFlags())

__getitem__(index: int) -> QtWidgets.QGraphicsItem

Source code in prettyqt\widgets\graphicsview.py

def __getitem__(self, index: int) -> QtWidgets.QGraphicsItem:
    return self.items()[index]

__setitem__(state)

Source code in prettyqt\widgets\graphicsview.py

def __setitem__(self, state):
    super().__setstate__(state)
    self.setScene(state["scene"])
    self.setBackgroundBrush(state["background_brush"])
    self.setForegroundBrush(state["foreground_brush"])
    self.set_transformation_anchor(state["transformation_anchor"])
    self.set_resize_anchor(state["resicze_anchor"])
    self.set_viewport_update_mode(state["viewport_update_mode"])
    self.set_drag_mode(state["drag_mode"])
    self.set_rubberband_selection_mode(state["rubberband_selection_mode"])
    self.setSceneRect(state["scene_rect"])
    self.set_cache_mode(state["cache_mode"])
    self.setInteractive(state["is_interactive"])

get_background_brush() -> gui.Brush

Source code in prettyqt\widgets\graphicsview.py

def get_background_brush(self) -> gui.Brush:
    return gui.Brush(self.backgroundBrush())

get_cache_mode() -> CacheModeStr

Return current cache mode.

Returns:

Type	Description
CacheModeStr	cache mode

Source code in prettyqt\widgets\graphicsview.py

def get_cache_mode(self) -> CacheModeStr:
    """Return current cache mode.

    Returns:
        cache mode
    """
    return CACHE_MODES.inverse[self.cacheMode()]

get_drag_mode() -> DragModeStr

Return current drag mode.

Returns:

Type	Description
DragModeStr	drag mode

Source code in prettyqt\widgets\graphicsview.py

def get_drag_mode(self) -> DragModeStr:
    """Return current drag mode.

    Returns:
        drag mode
    """
    return DRAG_MODE.inverse[self.dragMode()]

get_foreground_brush() -> gui.Brush

Source code in prettyqt\widgets\graphicsview.py

def get_foreground_brush(self) -> gui.Brush:
    return gui.Brush(self.foregroundBrush())

get_optimization_flags() -> list[OptimizationFlagStr]

Source code in prettyqt\widgets\graphicsview.py

def get_optimization_flags(self) -> list[OptimizationFlagStr]:
    return OPTIMIZATION_FLAGS.get_list(self.optimizationFlags())

get_resize_anchor() -> ViewportAnchorStr

Return current resize anchor.

Returns:

Type	Description
ViewportAnchorStr	resize anchor

Source code in prettyqt\widgets\graphicsview.py

def get_resize_anchor(self) -> ViewportAnchorStr:
    """Return current resize anchor.

    Returns:
        resize anchor
    """
    return VIEWPORT_ANCHOR.inverse[self.resizeAnchor()]

get_rubberband_selection_mode() -> constants.ItemSelectionModeStr

Return current rubberband selection mode.

Returns:

Type	Description
constants.ItemSelectionModeStr	rubberband selection mode

Source code in prettyqt\widgets\graphicsview.py

def get_rubberband_selection_mode(self) -> constants.ItemSelectionModeStr:
    """Return current rubberband selection mode.

    Returns:
        rubberband selection mode
    """
    return constants.ITEM_SELECTION_MODE.inverse[self.rubberBandSelectionMode()]

get_transformation_anchor() -> ViewportAnchorStr

Return current transformation anchor.

Returns:

Type	Description
ViewportAnchorStr	viewport anchor

Source code in prettyqt\widgets\graphicsview.py

def get_transformation_anchor(self) -> ViewportAnchorStr:
    """Return current transformation anchor.

    Returns:
        viewport anchor
    """
    return VIEWPORT_ANCHOR.inverse[self.transformationAnchor()]

get_viewport_update_mode() -> ViewportUpdateModeStr

Return current viewport update mode.

Returns:

Type	Description
ViewportUpdateModeStr	viewport update mode

Source code in prettyqt\widgets\graphicsview.py

def get_viewport_update_mode(self) -> ViewportUpdateModeStr:
    """Return current viewport update mode.

    Returns:
        viewport update mode
    """
    return VIEWPORT_UPDATE_MODE.inverse[self.viewportUpdateMode()]

invalidate_scene(rect: QtCore.QRectF, layer: widgets.graphicsscene.SceneLayerStr = 'all')

Source code in prettyqt\widgets\graphicsview.py

def invalidate_scene(
    self, rect: QtCore.QRectF, layer: widgets.graphicsscene.SceneLayerStr = "all"
):
    if layer not in widgets.graphicsscene.SCENE_LAYER:
        raise InvalidParamError(layer, widgets.graphicsscene.SCENE_LAYER)
    self.invalidateScene(rect, widgets.graphicsscene.SCENE_LAYER[layer])

serialize_fields()

Source code in prettyqt\widgets\graphicsview.py

def serialize_fields(self):
    return dict(
        scene=self.scene(),
        background_brush=self.get_background_brush(),
        foreground_brush=self.get_foreground_brush(),
        transformation_anchor=self.get_transformation_anchor(),
        resize_anchor=self.get_resize_anchor(),
        viewport_update_mode=self.get_viewport_update_mode(),
        drag_mode=self.get_drag_mode(),
        rubberband_selection_mode=self.get_rubberband_selection_mode(),
        scene_rect=core.RectF(self.sceneRect()),
        cache_mode=self.get_cache_mode(),
        is_interactive=self.isInteractive(),
    )

set_cache_mode(mode: CacheModeStr)

Set the cache mode.

Parameters:

Name	Type	Description	Default
mode	CacheModeStr	cache mode to use	required

Raises:

Type	Description
InvalidParamError	mode does not exist

Source code in prettyqt\widgets\graphicsview.py

def set_cache_mode(self, mode: CacheModeStr):
    """Set the cache mode.

    Args:
        mode: cache mode to use

    Raises:
        InvalidParamError: mode does not exist
    """
    if mode not in CACHE_MODES:
        raise InvalidParamError(mode, CACHE_MODES)
    self.setCacheMode(CACHE_MODES[mode])

set_drag_mode(mode: DragModeStr)

Set the behavior for dragging the mouse while the left mouse button is pressed.

Parameters:

Name	Type	Description	Default
mode	DragModeStr	drag mode to use	required

Raises:

Type	Description
InvalidParamError	mode does not exist

Source code in prettyqt\widgets\graphicsview.py

def set_drag_mode(self, mode: DragModeStr):
    """Set the behavior for dragging the mouse while the left mouse button is pressed.

    Args:
        mode: drag mode to use

    Raises:
        InvalidParamError: mode does not exist
    """
    if mode not in DRAG_MODE:
        raise InvalidParamError(mode, DRAG_MODE)
    self.setDragMode(DRAG_MODE[mode])

set_optimization_flags(*items: OptimizationFlagStr)

Source code in prettyqt\widgets\graphicsview.py

def set_optimization_flags(self, *items: OptimizationFlagStr):
    for item in items:
        if item not in OPTIMIZATION_FLAGS:
            raise InvalidParamError(item, OPTIMIZATION_FLAGS)
    flags = helpers.merge_flags(items, OPTIMIZATION_FLAGS)
    self.setOptimizationFlags(flags)

set_resize_anchor(mode: ViewportAnchorStr)

Set how the view should position the scene during resizes.

Parameters:

Name	Type	Description	Default
mode	ViewportAnchorStr	resize anchor to use	required

Raises:

Type	Description
InvalidParamError	mode does not exist

Source code in prettyqt\widgets\graphicsview.py

def set_resize_anchor(self, mode: ViewportAnchorStr):
    """Set how the view should position the scene during resizes.

    Args:
        mode: resize anchor to use

    Raises:
        InvalidParamError: mode does not exist
    """
    if mode not in VIEWPORT_ANCHOR:
        raise InvalidParamError(mode, VIEWPORT_ANCHOR)
    self.setResizeAnchor(VIEWPORT_ANCHOR[mode])

set_rubberband_selection_mode(mode: constants.ItemSelectionModeStr)

Set the behavior for selecting items with a rubber band selection rectangle.

Parameters:

Name	Type	Description	Default
mode	constants.ItemSelectionModeStr	rubberband selection mode to use	required

Raises:

Type	Description
InvalidParamError	mode does not exist

Source code in prettyqt\widgets\graphicsview.py

def set_rubberband_selection_mode(self, mode: constants.ItemSelectionModeStr):
    """Set the behavior for selecting items with a rubber band selection rectangle.

    Args:
        mode: rubberband selection mode to use

    Raises:
        InvalidParamError: mode does not exist
    """
    if mode not in constants.ITEM_SELECTION_MODE:
        raise InvalidParamError(mode, constants.ITEM_SELECTION_MODE)
    self.setRubberBandSelectionMode(constants.ITEM_SELECTION_MODE[mode])

set_transform(transform: datatypes.TransformType, combine: bool = False)

Source code in prettyqt\widgets\graphicsview.py

def set_transform(self, transform: datatypes.TransformType, combine: bool = False):
    if isinstance(transform, tuple):
        transform = gui.Transform(*transform)
    self.setTransform(transform, combine)

set_transformation_anchor(mode: ViewportAnchorStr)

Set how the view should position the scene during transformations.

Parameters:

Name	Type	Description	Default
mode	ViewportAnchorStr	transformation anchor to use	required

Raises:

Type	Description
InvalidParamError	mode does not exist

Source code in prettyqt\widgets\graphicsview.py

def set_transformation_anchor(self, mode: ViewportAnchorStr):
    """Set how the view should position the scene during transformations.

    Args:
        mode: transformation anchor to use

    Raises:
        InvalidParamError: mode does not exist
    """
    if mode not in VIEWPORT_ANCHOR:
        raise InvalidParamError(mode, VIEWPORT_ANCHOR)
    self.setTransformationAnchor(VIEWPORT_ANCHOR[mode])

set_viewport_update_mode(mode: ViewportUpdateModeStr)

Set how the viewport should update its contents.

Parameters:

Name	Type	Description	Default
mode	ViewportUpdateModeStr	viewport update mode to use	required

Raises:

Type	Description
InvalidParamError	mode does not exist

Source code in prettyqt\widgets\graphicsview.py

def set_viewport_update_mode(self, mode: ViewportUpdateModeStr):
    """Set how the viewport should update its contents.

    Args:
        mode: viewport update mode to use

    Raises:
        InvalidParamError: mode does not exist
    """
    if mode not in VIEWPORT_UPDATE_MODE:
        raise InvalidParamError(mode, VIEWPORT_UPDATE_MODE)
    self.setViewportUpdateMode(VIEWPORT_UPDATE_MODE[mode])

GraphicsWidget

Bases: GraphicsWidgetMixin, QtWidgets.QGraphicsWidget

Source code in prettyqt\widgets\graphicswidget.py

class GraphicsWidget(GraphicsWidgetMixin, QtWidgets.QGraphicsWidget):
    pass

GraphicsWidgetMixin

Bases: widgets.GraphicsObjectMixin, widgets.GraphicsLayoutItemMixin

Source code in prettyqt\widgets\graphicswidget.py

class GraphicsWidgetMixin(widgets.GraphicsObjectMixin, widgets.GraphicsLayoutItemMixin):
    def set_layout(self, layout: LayoutStr | QtWidgets.QGraphicsLayout | None):
        match layout:
            case None:
                return
            case QtWidgets.QGraphicsLayout():
                self.box = layout
            case "grid":
                self.box = widgets.GraphicsGridLayout()
            case "anchor":
                self.box = widgets.GraphicsAnchorLayout()
            case "horizontal" | "vertical":
                self.box = widgets.GraphicsLinearLayout(layout)
            case _:
                raise ValueError("Invalid Layout")
        self.setLayout(self.box)

    def set_focus_policy(self, policy: constants.FocusPolicyStr) -> None:
        """Set the way the widget accepts keyboard focus.

        Args:
            policy: Focus policy

        Raises:
            InvalidParamError: Description
        """
        if policy not in constants.FOCUS_POLICY:
            raise InvalidParamError(policy, constants.FOCUS_POLICY)
        self.setFocusPolicy(constants.FOCUS_POLICY[policy])

    def get_focus_policy(self) -> constants.FocusPolicyStr:
        """Return way the widget accepts keyboard focus.

        Returns:
            str: Focus policy
        """
        return constants.FOCUS_POLICY.inverse[self.focusPolicy()]

    def window_frame_section_at(
        self, point: datatypes.PointType
    ) -> constants.WindowFrameSectionStr:
        """Return the window frame section at given position.

        Returns:
            str: Window frame section
        """
        if isinstance(point, tuple):
            point = QtCore.QPoint(*point)
        return constants.WINDOW_FRAME_SECTION.inverse[self.windowFrameSectionAt(point)]

    def get_font(self) -> gui.Font:
        return gui.Font(self.font())

    def get_palette(self) -> gui.Palette:
        return gui.Palette(self.palette())

get_focus_policy() -> constants.FocusPolicyStr

Return way the widget accepts keyboard focus.

Returns:

Name	Type	Description
str	constants.FocusPolicyStr	Focus policy

Source code in prettyqt\widgets\graphicswidget.py

def get_focus_policy(self) -> constants.FocusPolicyStr:
    """Return way the widget accepts keyboard focus.

    Returns:
        str: Focus policy
    """
    return constants.FOCUS_POLICY.inverse[self.focusPolicy()]

get_font() -> gui.Font

Source code in prettyqt\widgets\graphicswidget.py

def get_font(self) -> gui.Font:
    return gui.Font(self.font())

get_palette() -> gui.Palette

Source code in prettyqt\widgets\graphicswidget.py

def get_palette(self) -> gui.Palette:
    return gui.Palette(self.palette())

set_focus_policy(policy: constants.FocusPolicyStr) -> None

Set the way the widget accepts keyboard focus.

Parameters:

Name	Type	Description	Default
policy	constants.FocusPolicyStr	Focus policy	required

Raises:

Type	Description
InvalidParamError	Description

Source code in prettyqt\widgets\graphicswidget.py

def set_focus_policy(self, policy: constants.FocusPolicyStr) -> None:
    """Set the way the widget accepts keyboard focus.

    Args:
        policy: Focus policy

    Raises:
        InvalidParamError: Description
    """
    if policy not in constants.FOCUS_POLICY:
        raise InvalidParamError(policy, constants.FOCUS_POLICY)
    self.setFocusPolicy(constants.FOCUS_POLICY[policy])

set_layout(layout: LayoutStr | QtWidgets.QGraphicsLayout | None)

Source code in prettyqt\widgets\graphicswidget.py

def set_layout(self, layout: LayoutStr | QtWidgets.QGraphicsLayout | None):
    match layout:
        case None:
            return
        case QtWidgets.QGraphicsLayout():
            self.box = layout
        case "grid":
            self.box = widgets.GraphicsGridLayout()
        case "anchor":
            self.box = widgets.GraphicsAnchorLayout()
        case "horizontal" | "vertical":
            self.box = widgets.GraphicsLinearLayout(layout)
        case _:
            raise ValueError("Invalid Layout")
    self.setLayout(self.box)

window_frame_section_at(point: datatypes.PointType) -> constants.WindowFrameSectionStr

Return the window frame section at given position.

Returns:

Name	Type	Description
str	constants.WindowFrameSectionStr	Window frame section

Source code in prettyqt\widgets\graphicswidget.py

def window_frame_section_at(
    self, point: datatypes.PointType
) -> constants.WindowFrameSectionStr:
    """Return the window frame section at given position.

    Returns:
        str: Window frame section
    """
    if isinstance(point, tuple):
        point = QtCore.QPoint(*point)
    return constants.WINDOW_FRAME_SECTION.inverse[self.windowFrameSectionAt(point)]

GridLayout

Bases: widgets.LayoutMixin, QtWidgets.QGridLayout

Source code in prettyqt\widgets\gridlayout.py

class GridLayout(widgets.LayoutMixin, QtWidgets.QGridLayout):
    def __getitem__(
        self, idx: tuple[int, int] | int | str
    ) -> QtWidgets.QWidget | QtWidgets.QLayout | None:
        if isinstance(idx, tuple):
            item = self.itemAtPosition(*idx)
        elif isinstance(idx, int):
            item = self.itemAt(idx)
        else:
            return self.find_child(QtCore.QObject, idx)
        widget = item.widget()
        return item.layout() if widget is None else widget

    def __setitem__(
        self,
        idx: tuple[int | slice, int | slice],
        value: QtWidgets.QWidget | QtWidgets.QLayout | QtWidgets.QLayoutItem,
    ):
        row, col = idx
        rowspan = row.stop - row.start + 1 if isinstance(row, slice) else 1
        colspan = col.stop - col.start + 1 if isinstance(col, slice) else 1
        rowstart = row.start if isinstance(row, slice) else row
        colstart = col.start if isinstance(col, slice) else col
        self.add(value, rowstart, colstart, rowspan, colspan)

    # def serialize_fields(self):
    #     widgets = []
    #     positions = []
    #     for i, item in enumerate(list(self)):
    #         widgets.append(item)
    #         positions.append(self.getItemPosition(i))
    #     return dict(widgets=widgets, positions=positions)

    # def __setstate__(self, state):
    #     for item, pos in zip(state["widgets"], state["positions"]):
    #         x, y, w, h = pos
    #         self[x : x + w - 1, y : y + h - 1] = item

    # def __reduce__(self):
    #     return type(self), (), self.__getstate__()

    def __iter__(self) -> Iterator[QtWidgets.QWidget | QtWidgets.QLayout]:
        return iter(item for i in range(self.count()) if (item := self[i]) is not None)

    def __add__(
        self,
        other: (
            tuple | list | QtWidgets.QWidget | QtWidgets.QLayout | QtWidgets.QLayoutItem
        ),
    ):
        if isinstance(other, tuple | list):
            for i, _control in enumerate(other):
                self[self.rowCount(), i] = other  # type: ignore
        else:
            self[self.rowCount(), 0 : self.columnCount() - 1] = other
        return self

    def add(
        self,
        item: QtWidgets.QWidget | QtWidgets.QLayout | QtWidgets.QLayoutItem,
        rowstart: int,
        colstart: int,
        rowspan: int = 1,
        colspan: int = 1,
    ):
        match item:
            case QtWidgets.QWidget():
                self.addWidget(item, rowstart, colstart, rowspan, colspan)
            case QtWidgets.QLayout():
                self.addLayout(item, rowstart, colstart, rowspan, colspan)
            case QtWidgets.QLayoutItem():
                self.addItem(item, rowstart, colstart, rowspan, colspan)

    def append(self, item: QtWidgets.QWidget | QtWidgets.QLayout | QtWidgets.QLayoutItem):
        self[self.rowCount(), 0 : self.columnCount() - 1] = item

    def set_origin_corner(self, corner: constants.CornerStr):
        """Set the origin corner.

        Args:
            corner: origin corner

        Raises:
            InvalidParamError: corner does not exist
        """
        if corner not in constants.CORNER:
            raise InvalidParamError(corner, constants.CORNER)
        self.setOriginCorner(constants.CORNER[corner])

    def get_origin_corner(self) -> constants.CornerStr:
        """Return current origin corner.

        Returns:
            origin corner
        """
        return constants.CORNER.inverse[self.originCorner()]

__add__(other: tuple | list | QtWidgets.QWidget | QtWidgets.QLayout | QtWidgets.QLayoutItem)

Source code in prettyqt\widgets\gridlayout.py

def __add__(
    self,
    other: (
        tuple | list | QtWidgets.QWidget | QtWidgets.QLayout | QtWidgets.QLayoutItem
    ),
):
    if isinstance(other, tuple | list):
        for i, _control in enumerate(other):
            self[self.rowCount(), i] = other  # type: ignore
    else:
        self[self.rowCount(), 0 : self.columnCount() - 1] = other
    return self

__getitem__(idx: tuple[int, int] | int | str) -> QtWidgets.QWidget | QtWidgets.QLayout | None

Source code in prettyqt\widgets\gridlayout.py

def __getitem__(
    self, idx: tuple[int, int] | int | str
) -> QtWidgets.QWidget | QtWidgets.QLayout | None:
    if isinstance(idx, tuple):
        item = self.itemAtPosition(*idx)
    elif isinstance(idx, int):
        item = self.itemAt(idx)
    else:
        return self.find_child(QtCore.QObject, idx)
    widget = item.widget()
    return item.layout() if widget is None else widget

__iter__() -> Iterator[QtWidgets.QWidget | QtWidgets.QLayout]

Source code in prettyqt\widgets\gridlayout.py

def __iter__(self) -> Iterator[QtWidgets.QWidget | QtWidgets.QLayout]:
    return iter(item for i in range(self.count()) if (item := self[i]) is not None)

__setitem__(idx: tuple[int | slice, int | slice], value: QtWidgets.QWidget | QtWidgets.QLayout | QtWidgets.QLayoutItem)

Source code in prettyqt\widgets\gridlayout.py

def __setitem__(
    self,
    idx: tuple[int | slice, int | slice],
    value: QtWidgets.QWidget | QtWidgets.QLayout | QtWidgets.QLayoutItem,
):
    row, col = idx
    rowspan = row.stop - row.start + 1 if isinstance(row, slice) else 1
    colspan = col.stop - col.start + 1 if isinstance(col, slice) else 1
    rowstart = row.start if isinstance(row, slice) else row
    colstart = col.start if isinstance(col, slice) else col
    self.add(value, rowstart, colstart, rowspan, colspan)

add(item: QtWidgets.QWidget | QtWidgets.QLayout | QtWidgets.QLayoutItem, rowstart: int, colstart: int, rowspan: int = 1, colspan: int = 1)

Source code in prettyqt\widgets\gridlayout.py

def add(
    self,
    item: QtWidgets.QWidget | QtWidgets.QLayout | QtWidgets.QLayoutItem,
    rowstart: int,
    colstart: int,
    rowspan: int = 1,
    colspan: int = 1,
):
    match item:
        case QtWidgets.QWidget():
            self.addWidget(item, rowstart, colstart, rowspan, colspan)
        case QtWidgets.QLayout():
            self.addLayout(item, rowstart, colstart, rowspan, colspan)
        case QtWidgets.QLayoutItem():
            self.addItem(item, rowstart, colstart, rowspan, colspan)

append(item: QtWidgets.QWidget | QtWidgets.QLayout | QtWidgets.QLayoutItem)

Source code in prettyqt\widgets\gridlayout.py

def append(self, item: QtWidgets.QWidget | QtWidgets.QLayout | QtWidgets.QLayoutItem):
    self[self.rowCount(), 0 : self.columnCount() - 1] = item

get_origin_corner() -> constants.CornerStr

Return current origin corner.

Returns:

Type	Description
constants.CornerStr	origin corner

Source code in prettyqt\widgets\gridlayout.py

def get_origin_corner(self) -> constants.CornerStr:
    """Return current origin corner.

    Returns:
        origin corner
    """
    return constants.CORNER.inverse[self.originCorner()]

set_origin_corner(corner: constants.CornerStr)

Set the origin corner.

Parameters:

Name	Type	Description	Default
corner	constants.CornerStr	origin corner	required

Raises:

Type	Description
InvalidParamError	corner does not exist

Source code in prettyqt\widgets\gridlayout.py

def set_origin_corner(self, corner: constants.CornerStr):
    """Set the origin corner.

    Args:
        corner: origin corner

    Raises:
        InvalidParamError: corner does not exist
    """
    if corner not in constants.CORNER:
        raise InvalidParamError(corner, constants.CORNER)
    self.setOriginCorner(constants.CORNER[corner])

GroupBox

Bases: widgets.WidgetMixin, QtWidgets.QGroupBox

GroupBox widget.

A group box provides a frame, a title on top, a keyboard shortcut, and displays various other widgets inside itself. The keyboard shortcut moves keyboard focus to one of the group box's child widgets.

Source code in prettyqt\widgets\groupbox.py

class GroupBox(widgets.WidgetMixin, QtWidgets.QGroupBox):
    """GroupBox widget.

    A group box provides a frame, a title on top, a keyboard shortcut,
    and displays various other widgets inside itself.
    The keyboard shortcut moves keyboard focus to one of the group box's child widgets.
    """

    def __init__(
        self,
        title: str = "",
        checkable: bool = False,
        parent: QtWidgets.QWidget | None = None,
    ):
        super().__init__(title, parent)
        self.setCheckable(checkable)

    def __repr__(self):
        return get_repr(self, self.title())

    def set_title(self, title: str):
        self.setTitle(title)

    def set_alignment(self, alignment):
        self.setAlignment(constants.H_ALIGNMENT[alignment])

    def set_enabled(self, state):
        for widget in self.layout():
            widget.setEnabled(state)

__init__(title: str = '', checkable: bool = False, parent: QtWidgets.QWidget | None = None)

Source code in prettyqt\widgets\groupbox.py

def __init__(
    self,
    title: str = "",
    checkable: bool = False,
    parent: QtWidgets.QWidget | None = None,
):
    super().__init__(title, parent)
    self.setCheckable(checkable)

__repr__()

Source code in prettyqt\widgets\groupbox.py

def __repr__(self):
    return get_repr(self, self.title())

set_alignment(alignment)

Source code in prettyqt\widgets\groupbox.py

def set_alignment(self, alignment):
    self.setAlignment(constants.H_ALIGNMENT[alignment])

set_enabled(state)

Source code in prettyqt\widgets\groupbox.py

def set_enabled(self, state):
    for widget in self.layout():
        widget.setEnabled(state)

set_title(title: str)

Source code in prettyqt\widgets\groupbox.py

def set_title(self, title: str):
    self.setTitle(title)

HeaderView

Bases: HeaderViewMixin, QtWidgets.QHeaderView

Source code in prettyqt\widgets\headerview.py

class HeaderView(HeaderViewMixin, QtWidgets.QHeaderView):
    pass

InputDialog

Bases: widgets.DialogMixin, QtWidgets.QInputDialog

Source code in prettyqt\widgets\inputdialog.py

class InputDialog(widgets.DialogMixin, QtWidgets.QInputDialog):
    @classmethod
    def get_int(
        cls,
        title: str = "",
        label: str = "",
        icon: datatypes.IconType = None,
    ) -> int | None:
        par = widgets.Dialog()
        par.set_icon(icon)
        v = cls.getInt(par, title, label, value=0)
        return v[0] if v[1] else None

    @classmethod
    def get_float(
        cls,
        title: str = "",
        label: str = "",
        icon: datatypes.IconType = None,
    ) -> float | None:
        par = widgets.Dialog()
        par.set_icon(icon)
        v = cls.getDouble(par, title, label, value=0.0)
        return v[0] if v[1] else None

    @classmethod
    def get_text(
        cls,
        title: str = "",
        label: str = "",
        icon: datatypes.IconType = None,
        default_value: str = "",
        echo_mode: widgets.lineedit.EchoModeStr = "normal",
    ) -> str | None:
        par = widgets.Dialog()
        par.set_icon(icon)
        if echo_mode not in widgets.lineedit.ECHO_MODE:
            raise InvalidParamError(echo_mode, widgets.lineedit.ECHO_MODE)
        v = cls.getText(
            par, title, label, widgets.lineedit.ECHO_MODE[echo_mode], default_value
        )
        return v[0] if v[1] else None

    @classmethod
    def get_item(
        cls,
        items: list[str],
        title: str = "",
        label: str = "",
        icon: datatypes.IconType = None,
        editable: bool = False,
    ) -> str | None:
        par = widgets.Dialog()
        par.set_icon(icon)
        v = cls.getItem(par, title, label, items, editable=editable, current=0)
        return v[0] if v[1] else None

    def set_text_echo_mode(self, mode: widgets.lineedit.EchoModeStr):
        """Set text echo mode.

        Args:
            mode: echo mode to use

        Raises:
            InvalidParamError: invalid echo mode
        """
        if mode not in widgets.lineedit.ECHO_MODE:
            raise InvalidParamError(mode, widgets.lineedit.ECHO_MODE)
        self.setTextEchoMode(widgets.lineedit.ECHO_MODE[mode])

    def get_text_echo_mode(self) -> widgets.lineedit.EchoModeStr:
        """Return text echo mode.

        Returns:
            echo mode
        """
        return widgets.lineedit.ECHO_MODE.inverse[self.textEchoMode()]

    def set_input_mode(self, mode: InputModeStr):
        """Set input mode.

        Args:
            mode: input mode to use

        Raises:
            InvalidParamError: invalid input mode
        """
        if mode not in INPUT_MODE:
            raise InvalidParamError(mode, INPUT_MODE)
        self.setInputMode(INPUT_MODE[mode])

    def get_input_mode(self) -> InputModeStr:
        """Return input mode.

        Returns:
            input mode
        """
        return INPUT_MODE.inverse[self.inputMode()]

get_float(title: str = '', label: str = '', icon: datatypes.IconType = None) -> float | None classmethod

Source code in prettyqt\widgets\inputdialog.py

@classmethod
def get_float(
    cls,
    title: str = "",
    label: str = "",
    icon: datatypes.IconType = None,
) -> float | None:
    par = widgets.Dialog()
    par.set_icon(icon)
    v = cls.getDouble(par, title, label, value=0.0)
    return v[0] if v[1] else None

get_input_mode() -> InputModeStr

Return input mode.

Returns:

Type	Description
InputModeStr	input mode

Source code in prettyqt\widgets\inputdialog.py

def get_input_mode(self) -> InputModeStr:
    """Return input mode.

    Returns:
        input mode
    """
    return INPUT_MODE.inverse[self.inputMode()]

get_int(title: str = '', label: str = '', icon: datatypes.IconType = None) -> int | None classmethod

Source code in prettyqt\widgets\inputdialog.py

@classmethod
def get_int(
    cls,
    title: str = "",
    label: str = "",
    icon: datatypes.IconType = None,
) -> int | None:
    par = widgets.Dialog()
    par.set_icon(icon)
    v = cls.getInt(par, title, label, value=0)
    return v[0] if v[1] else None

get_item(items: list[str], title: str = '', label: str = '', icon: datatypes.IconType = None, editable: bool = False) -> str | None classmethod

Source code in prettyqt\widgets\inputdialog.py

@classmethod
def get_item(
    cls,
    items: list[str],
    title: str = "",
    label: str = "",
    icon: datatypes.IconType = None,
    editable: bool = False,
) -> str | None:
    par = widgets.Dialog()
    par.set_icon(icon)
    v = cls.getItem(par, title, label, items, editable=editable, current=0)
    return v[0] if v[1] else None

get_text(title: str = '', label: str = '', icon: datatypes.IconType = None, default_value: str = '', echo_mode: widgets.lineedit.EchoModeStr = 'normal') -> str | None classmethod

Source code in prettyqt\widgets\inputdialog.py

@classmethod
def get_text(
    cls,
    title: str = "",
    label: str = "",
    icon: datatypes.IconType = None,
    default_value: str = "",
    echo_mode: widgets.lineedit.EchoModeStr = "normal",
) -> str | None:
    par = widgets.Dialog()
    par.set_icon(icon)
    if echo_mode not in widgets.lineedit.ECHO_MODE:
        raise InvalidParamError(echo_mode, widgets.lineedit.ECHO_MODE)
    v = cls.getText(
        par, title, label, widgets.lineedit.ECHO_MODE[echo_mode], default_value
    )
    return v[0] if v[1] else None

get_text_echo_mode() -> widgets.lineedit.EchoModeStr

Return text echo mode.

Returns:

Type	Description
widgets.lineedit.EchoModeStr	echo mode

Source code in prettyqt\widgets\inputdialog.py

def get_text_echo_mode(self) -> widgets.lineedit.EchoModeStr:
    """Return text echo mode.

    Returns:
        echo mode
    """
    return widgets.lineedit.ECHO_MODE.inverse[self.textEchoMode()]

set_input_mode(mode: InputModeStr)

Set input mode.

Parameters:

Name	Type	Description	Default
mode	InputModeStr	input mode to use	required

Raises:

Type	Description
InvalidParamError	invalid input mode

Source code in prettyqt\widgets\inputdialog.py

def set_input_mode(self, mode: InputModeStr):
    """Set input mode.

    Args:
        mode: input mode to use

    Raises:
        InvalidParamError: invalid input mode
    """
    if mode not in INPUT_MODE:
        raise InvalidParamError(mode, INPUT_MODE)
    self.setInputMode(INPUT_MODE[mode])

set_text_echo_mode(mode: widgets.lineedit.EchoModeStr)

Set text echo mode.

Parameters:

Name	Type	Description	Default
mode	widgets.lineedit.EchoModeStr	echo mode to use	required

Raises:

Type	Description
InvalidParamError	invalid echo mode

Source code in prettyqt\widgets\inputdialog.py

def set_text_echo_mode(self, mode: widgets.lineedit.EchoModeStr):
    """Set text echo mode.

    Args:
        mode: echo mode to use

    Raises:
        InvalidParamError: invalid echo mode
    """
    if mode not in widgets.lineedit.ECHO_MODE:
        raise InvalidParamError(mode, widgets.lineedit.ECHO_MODE)
    self.setTextEchoMode(widgets.lineedit.ECHO_MODE[mode])

ItemDelegate

Bases: widgets.AbstractItemDelegateMixin, QtWidgets.QItemDelegate

Source code in prettyqt\widgets\itemdelegate.py

class ItemDelegate(widgets.AbstractItemDelegateMixin, QtWidgets.QItemDelegate):
    pass

ItemEditorCreatorBase

Bases: QtWidgets.QItemEditorCreatorBase

Source code in prettyqt\widgets\itemeditorcreatorbase.py

class ItemEditorCreatorBase(QtWidgets.QItemEditorCreatorBase):
    pass

ItemEditorFactory

Bases: QtWidgets.QItemEditorFactory

Source code in prettyqt\widgets\itemeditorfactory.py

class ItemEditorFactory(QtWidgets.QItemEditorFactory):
    @classmethod
    def register_default_editor(
        cls, editor_cls: type[QtWidgets.QWidget], typ: int | None = None
    ):
        factory = cls.defaultFactory()
        factory.register_editor(editor_cls, typ)
        cls.setDefaultFactory(factory)

    def register_editor(
        self,
        editor_cls: type[QtWidgets.QWidget],
        typ: int | None = None,
        property_name: str = "",
    ):
        class EditorCreator(widgets.ItemEditorCreatorBase):
            def createWidget(self, parent: QtWidgets.QWidget) -> QtWidgets.QWidget:
                return editor_cls(parent=parent)

            def valuePropertyName(self) -> QtCore.QByteArray:
                return QtCore.QByteArray(property_name.encode())

        if typ is None:
            typ = editor_cls.staticMetaObject.userProperty().userType()
        self.registerEditor(typ, EditorCreator())

register_default_editor(editor_cls: type[QtWidgets.QWidget], typ: int | None = None) classmethod

Source code in prettyqt\widgets\itemeditorfactory.py

@classmethod
def register_default_editor(
    cls, editor_cls: type[QtWidgets.QWidget], typ: int | None = None
):
    factory = cls.defaultFactory()
    factory.register_editor(editor_cls, typ)
    cls.setDefaultFactory(factory)

register_editor(editor_cls: type[QtWidgets.QWidget], typ: int | None = None, property_name: str = '')

Source code in prettyqt\widgets\itemeditorfactory.py

def register_editor(
    self,
    editor_cls: type[QtWidgets.QWidget],
    typ: int | None = None,
    property_name: str = "",
):
    class EditorCreator(widgets.ItemEditorCreatorBase):
        def createWidget(self, parent: QtWidgets.QWidget) -> QtWidgets.QWidget:
            return editor_cls(parent=parent)

        def valuePropertyName(self) -> QtCore.QByteArray:
            return QtCore.QByteArray(property_name.encode())

    if typ is None:
        typ = editor_cls.staticMetaObject.userProperty().userType()
    self.registerEditor(typ, EditorCreator())

KeySequenceEdit

Bases: widgets.WidgetMixin, QtWidgets.QKeySequenceEdit

Source code in prettyqt\widgets\keysequenceedit.py

class KeySequenceEdit(widgets.WidgetMixin, QtWidgets.QKeySequenceEdit):
    value_changed = core.Signal(QtGui.QKeySequence)

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.keySequenceChanged.connect(self.value_changed)

    def __repr__(self):
        return get_repr(self, self.get_value())

    def set_value(self, value: str):
        seq = gui.KeySequence.fromString(value)
        self.setKeySequence(seq)

    def get_value(self) -> str:
        return self.keySequence().toString()

    def is_valid(self) -> bool:
        return True

value_changed = core.Signal(QtGui.QKeySequence) class-attribute

__init__(*args, **kwargs)

Source code in prettyqt\widgets\keysequenceedit.py

def __init__(self, *args, **kwargs):
    super().__init__(*args, **kwargs)
    self.keySequenceChanged.connect(self.value_changed)

__repr__()

Source code in prettyqt\widgets\keysequenceedit.py

def __repr__(self):
    return get_repr(self, self.get_value())

get_value() -> str

Source code in prettyqt\widgets\keysequenceedit.py

def get_value(self) -> str:
    return self.keySequence().toString()

is_valid() -> bool

Source code in prettyqt\widgets\keysequenceedit.py

def is_valid(self) -> bool:
    return True

set_value(value: str)

Source code in prettyqt\widgets\keysequenceedit.py

def set_value(self, value: str):
    seq = gui.KeySequence.fromString(value)
    self.setKeySequence(seq)

LCDNumber

Bases: widgets.FrameMixin, QtWidgets.QLCDNumber

Source code in prettyqt\widgets\lcdnumber.py

class LCDNumber(widgets.FrameMixin, QtWidgets.QLCDNumber):
    def set_mode(self, mode: ModeStr):
        """Set the lcd mode.

        Args:
            mode: lcd mode to use

        Raises:
            InvalidParamError: lcd mode does not exist
        """
        if mode not in MODE:
            raise InvalidParamError(mode, MODE)
        self.setMode(MODE[mode])

    def get_mode(self) -> ModeStr:
        """Return current lcd mode.

        Returns:
            lcd mode
        """
        return MODE.inverse[self.mode()]

    def set_segment_style(self, mode: SegmentStyleStr):
        """Set the segment style.

        Args:
            mode: segment style to use

        Raises:
            InvalidParamError: segment style does not exist
        """
        if mode not in SEGMENT_STYLE:
            raise InvalidParamError(mode, SEGMENT_STYLE)
        self.setSegmentStyle(SEGMENT_STYLE[mode])

    def get_segment_style(self) -> SegmentStyleStr:
        """Return current segment style.

        Returns:
            segment style
        """
        return SEGMENT_STYLE.inverse[self.segmentStyle()]

    def set_value(self, value: float | str):
        self.display(value)

    def get_value(self) -> float:
        return self.value()

get_mode() -> ModeStr

Return current lcd mode.

Returns:

Type	Description
ModeStr	lcd mode

Source code in prettyqt\widgets\lcdnumber.py

def get_mode(self) -> ModeStr:
    """Return current lcd mode.

    Returns:
        lcd mode
    """
    return MODE.inverse[self.mode()]

get_segment_style() -> SegmentStyleStr

Return current segment style.

Returns:

Type	Description
SegmentStyleStr	segment style

Source code in prettyqt\widgets\lcdnumber.py

def get_segment_style(self) -> SegmentStyleStr:
    """Return current segment style.

    Returns:
        segment style
    """
    return SEGMENT_STYLE.inverse[self.segmentStyle()]

get_value() -> float

Source code in prettyqt\widgets\lcdnumber.py

def get_value(self) -> float:
    return self.value()

set_mode(mode: ModeStr)

Set the lcd mode.

Parameters:

Name	Type	Description	Default
mode	ModeStr	lcd mode to use	required

Raises:

Type	Description
InvalidParamError	lcd mode does not exist

Source code in prettyqt\widgets\lcdnumber.py

def set_mode(self, mode: ModeStr):
    """Set the lcd mode.

    Args:
        mode: lcd mode to use

    Raises:
        InvalidParamError: lcd mode does not exist
    """
    if mode not in MODE:
        raise InvalidParamError(mode, MODE)
    self.setMode(MODE[mode])

set_segment_style(mode: SegmentStyleStr)

Set the segment style.

Parameters:

Name	Type	Description	Default
mode	SegmentStyleStr	segment style to use	required

Raises:

Type	Description
InvalidParamError	segment style does not exist

Source code in prettyqt\widgets\lcdnumber.py

def set_segment_style(self, mode: SegmentStyleStr):
    """Set the segment style.

    Args:
        mode: segment style to use

    Raises:
        InvalidParamError: segment style does not exist
    """
    if mode not in SEGMENT_STYLE:
        raise InvalidParamError(mode, SEGMENT_STYLE)
    self.setSegmentStyle(SEGMENT_STYLE[mode])

set_value(value: float | str)

Source code in prettyqt\widgets\lcdnumber.py

def set_value(self, value: float | str):
    self.display(value)

Label

Bases: widgets.FrameMixin, QtWidgets.QLabel

Source code in prettyqt\widgets\label.py

class Label(widgets.FrameMixin, QtWidgets.QLabel):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.openExternalLinks()

    def __repr__(self):
        return get_repr(self, self.text())

    def allow_links(self) -> Label:
        # self.setText("<a href=\"http://example.com/\">Click Here!</a>")
        self.setTextFormat(QtCore.Qt.TextFormat.RichText)
        self.setTextInteractionFlags(
            QtCore.Qt.TextInteractionFlag.TextBrowserInteraction  # type: ignore
        )
        self.setOpenExternalLinks(True)
        return self

    def set_alignment(
        self,
        horizontal: constants.HorizontalAlignmentStr | None = None,
        vertical: constants.VerticalAlignmentStr | None = None,
    ):
        """Set the alignment of the label's contents."""
        match horizontal, vertical:
            case None, None:
                return self
            case None, _:
                flag = constants.V_ALIGNMENT[vertical]
            case _, None:
                flag = constants.H_ALIGNMENT[horizontal]
            case _, _:
                flag = constants.V_ALIGNMENT[vertical] | constants.H_ALIGNMENT[horizontal]
        self.setAlignment(flag)
        return self

    def get_horizontal_alignment(self) -> constants.HorizontalAlignmentStr:
        align = self.alignment()
        if align & constants.ALIGN_RIGHT:  # type: ignore
            return "right"
        elif align & constants.ALIGN_H_CENTER:  # type: ignore
            return "center"
        elif align & constants.ALIGN_JUSTIFY:  # type: ignore
            return "justify"
        else:
            return "left"

    def get_vertical_alignment(self) -> constants.VerticalAlignmentStr:
        align = self.alignment()
        if align & constants.ALIGN_TOP:  # type: ignore
            return "top"
        elif align & constants.ALIGN_BOTTOM:  # type: ignore
            return "bottom"
        elif align & constants.ALIGN_BASELINE:  # type: ignore
            return "baseline"
        else:
            return "center"

    def set_indent(self, indent: int) -> Label:
        """Set the label's text indent in pixels."""
        self.setIndent(indent)
        return self

    def set_text_format(self, text_format: TextFormatStr) -> Label:
        """Set the text format.

        Args:
            text_format: text format to use

        Raises:
            InvalidParamError: text format does not exist
        """
        if text_format not in TEXT_FORMAT:
            raise InvalidParamError(text_format, TEXT_FORMAT)
        self.setTextFormat(TEXT_FORMAT[text_format])
        return self

    def get_text_format(self) -> TextFormatStr:
        """Return current text format.

        Returns:
            text format
        """
        return TEXT_FORMAT.inverse[self.textFormat()]

    def set_text_interaction(self, *types: TextInteractionStr) -> Label:
        """Set the text interaction mode.

        Args:
            types: text interaction mode to use

        Raises:
            InvalidParamError: text interaction mode does not exist
        """
        for item in types:
            if item not in TEXT_INTERACTION:
                raise InvalidParamError(item, TEXT_INTERACTION)
        flags = helpers.merge_flags(types, TEXT_INTERACTION)
        self.setTextInteractionFlags(flags)
        return self

    def get_text_interaction(self) -> list[TextInteractionStr]:
        """Return current text interaction mode.

        Returns:
            list of text interaction modes
        """
        return TEXT_INTERACTION.get_list(self.textInteractionFlags())

    def set_text(self, text: str) -> Label:
        """Set the label's text."""
        self.setText(text)
        return self

    def set_bold(self, bold: bool = True) -> Label:
        font = self.font()
        font.setBold(bold)
        self.setFont(font)
        return self

    def set_italic(self, italic: bool = True) -> Label:
        font = self.font()
        font.setItalic(italic)
        self.setFont(font)
        return self

    def set_point_size(self, size: int) -> Label:
        font = self.font()
        font.setPointSize(size)
        self.setFont(font)
        return self

    def set_weight(self, weight: gui.font.WeightStr) -> Label:
        """Set the font weight.

        Args:
            weight: font weight

        Raises:
            InvalidParamError: invalid font weight
        """
        if weight not in gui.font.WEIGHT:
            raise InvalidParamError(weight, gui.font.WEIGHT)
        font = self.font()
        font.setWeight(gui.font.WEIGHT[weight])
        self.setFont(font)
        return self

    def set_color(self, color: datatypes.ColorType) -> Label:
        with self.edit_stylesheet() as ss:
            if color is None:
                ss.color.setValue("")
            else:
                color = colors.get_color(color)
                ss.color.setValue(color.name())
        return self

    def set_image(self, path: datatypes.PathType, width: int = 300) -> Label:
        self.setScaledContents(True)
        self.set_alignment(horizontal="center")
        self.setText(
            "<html><head/><body><p>"
            f"<img src={os.fspath(path)!r} width={str(width)!r}/>"
            "</p></body></html>"
        )
        return self

    @classmethod
    def image_from_path(
        cls, path: datatypes.PathType, parent: QtWidgets.QWidget | None = None
    ) -> Label:
        pixmap = gui.Pixmap.from_file(path)
        label = cls(parent=parent)
        label.setPixmap(pixmap)
        label.resize(pixmap.width(), pixmap.height())
        return label

__init__(*args, **kwargs)

Source code in prettyqt\widgets\label.py

def __init__(self, *args, **kwargs):
    super().__init__(*args, **kwargs)
    self.openExternalLinks()

__repr__()

Source code in prettyqt\widgets\label.py

def __repr__(self):
    return get_repr(self, self.text())

allow_links() -> Label

Source code in prettyqt\widgets\label.py

def allow_links(self) -> Label:
    # self.setText("<a href=\"http://example.com/\">Click Here!</a>")
    self.setTextFormat(QtCore.Qt.TextFormat.RichText)
    self.setTextInteractionFlags(
        QtCore.Qt.TextInteractionFlag.TextBrowserInteraction  # type: ignore
    )
    self.setOpenExternalLinks(True)
    return self

get_horizontal_alignment() -> constants.HorizontalAlignmentStr

Source code in prettyqt\widgets\label.py

def get_horizontal_alignment(self) -> constants.HorizontalAlignmentStr:
    align = self.alignment()
    if align & constants.ALIGN_RIGHT:  # type: ignore
        return "right"
    elif align & constants.ALIGN_H_CENTER:  # type: ignore
        return "center"
    elif align & constants.ALIGN_JUSTIFY:  # type: ignore
        return "justify"
    else:
        return "left"

get_text_format() -> TextFormatStr

Return current text format.

Returns:

Type	Description
TextFormatStr	text format

Source code in prettyqt\widgets\label.py

def get_text_format(self) -> TextFormatStr:
    """Return current text format.

    Returns:
        text format
    """
    return TEXT_FORMAT.inverse[self.textFormat()]

get_text_interaction() -> list[TextInteractionStr]

Return current text interaction mode.

Returns:

Type	Description
list[TextInteractionStr]	list of text interaction modes

Source code in prettyqt\widgets\label.py

def get_text_interaction(self) -> list[TextInteractionStr]:
    """Return current text interaction mode.

    Returns:
        list of text interaction modes
    """
    return TEXT_INTERACTION.get_list(self.textInteractionFlags())

get_vertical_alignment() -> constants.VerticalAlignmentStr

Source code in prettyqt\widgets\label.py

def get_vertical_alignment(self) -> constants.VerticalAlignmentStr:
    align = self.alignment()
    if align & constants.ALIGN_TOP:  # type: ignore
        return "top"
    elif align & constants.ALIGN_BOTTOM:  # type: ignore
        return "bottom"
    elif align & constants.ALIGN_BASELINE:  # type: ignore
        return "baseline"
    else:
        return "center"

image_from_path(path: datatypes.PathType, parent: QtWidgets.QWidget | None = None) -> Label classmethod

Source code in prettyqt\widgets\label.py

@classmethod
def image_from_path(
    cls, path: datatypes.PathType, parent: QtWidgets.QWidget | None = None
) -> Label:
    pixmap = gui.Pixmap.from_file(path)
    label = cls(parent=parent)
    label.setPixmap(pixmap)
    label.resize(pixmap.width(), pixmap.height())
    return label

set_alignment(horizontal: constants.HorizontalAlignmentStr | None = None, vertical: constants.VerticalAlignmentStr | None = None)

Set the alignment of the label's contents.

Source code in prettyqt\widgets\label.py

def set_alignment(
    self,
    horizontal: constants.HorizontalAlignmentStr | None = None,
    vertical: constants.VerticalAlignmentStr | None = None,
):
    """Set the alignment of the label's contents."""
    match horizontal, vertical:
        case None, None:
            return self
        case None, _:
            flag = constants.V_ALIGNMENT[vertical]
        case _, None:
            flag = constants.H_ALIGNMENT[horizontal]
        case _, _:
            flag = constants.V_ALIGNMENT[vertical] | constants.H_ALIGNMENT[horizontal]
    self.setAlignment(flag)
    return self

set_bold(bold: bool = True) -> Label

Source code in prettyqt\widgets\label.py

def set_bold(self, bold: bool = True) -> Label:
    font = self.font()
    font.setBold(bold)
    self.setFont(font)
    return self

set_color(color: datatypes.ColorType) -> Label

Source code in prettyqt\widgets\label.py

def set_color(self, color: datatypes.ColorType) -> Label:
    with self.edit_stylesheet() as ss:
        if color is None:
            ss.color.setValue("")
        else:
            color = colors.get_color(color)
            ss.color.setValue(color.name())
    return self

set_image(path: datatypes.PathType, width: int = 300) -> Label

Source code in prettyqt\widgets\label.py

def set_image(self, path: datatypes.PathType, width: int = 300) -> Label:
    self.setScaledContents(True)
    self.set_alignment(horizontal="center")
    self.setText(
        "<html><head/><body><p>"
        f"<img src={os.fspath(path)!r} width={str(width)!r}/>"
        "</p></body></html>"
    )
    return self

set_indent(indent: int) -> Label

Set the label's text indent in pixels.

Source code in prettyqt\widgets\label.py

def set_indent(self, indent: int) -> Label:
    """Set the label's text indent in pixels."""
    self.setIndent(indent)
    return self

set_italic(italic: bool = True) -> Label

Source code in prettyqt\widgets\label.py

def set_italic(self, italic: bool = True) -> Label:
    font = self.font()
    font.setItalic(italic)
    self.setFont(font)
    return self

set_point_size(size: int) -> Label

Source code in prettyqt\widgets\label.py

def set_point_size(self, size: int) -> Label:
    font = self.font()
    font.setPointSize(size)
    self.setFont(font)
    return self

set_text(text: str) -> Label

Set the label's text.

Source code in prettyqt\widgets\label.py

def set_text(self, text: str) -> Label:
    """Set the label's text."""
    self.setText(text)
    return self

set_text_format(text_format: TextFormatStr) -> Label

Set the text format.

Parameters:

Name	Type	Description	Default
text_format	TextFormatStr	text format to use	required

Raises:

Type	Description
InvalidParamError	text format does not exist

Source code in prettyqt\widgets\label.py

def set_text_format(self, text_format: TextFormatStr) -> Label:
    """Set the text format.

    Args:
        text_format: text format to use

    Raises:
        InvalidParamError: text format does not exist
    """
    if text_format not in TEXT_FORMAT:
        raise InvalidParamError(text_format, TEXT_FORMAT)
    self.setTextFormat(TEXT_FORMAT[text_format])
    return self

set_text_interaction(*types: TextInteractionStr) -> Label

Set the text interaction mode.

Parameters:

Name	Type	Description	Default
types	TextInteractionStr	text interaction mode to use	()

Raises:

Type	Description
InvalidParamError	text interaction mode does not exist

Source code in prettyqt\widgets\label.py

def set_text_interaction(self, *types: TextInteractionStr) -> Label:
    """Set the text interaction mode.

    Args:
        types: text interaction mode to use

    Raises:
        InvalidParamError: text interaction mode does not exist
    """
    for item in types:
        if item not in TEXT_INTERACTION:
            raise InvalidParamError(item, TEXT_INTERACTION)
    flags = helpers.merge_flags(types, TEXT_INTERACTION)
    self.setTextInteractionFlags(flags)
    return self

set_weight(weight: gui.font.WeightStr) -> Label

Set the font weight.

Parameters:

Name	Type	Description	Default
weight	gui.font.WeightStr	font weight	required

Raises:

Type	Description
InvalidParamError	invalid font weight

Source code in prettyqt\widgets\label.py

def set_weight(self, weight: gui.font.WeightStr) -> Label:
    """Set the font weight.

    Args:
        weight: font weight

    Raises:
        InvalidParamError: invalid font weight
    """
    if weight not in gui.font.WEIGHT:
        raise InvalidParamError(weight, gui.font.WEIGHT)
    font = self.font()
    font.setWeight(gui.font.WEIGHT[weight])
    self.setFont(font)
    return self

Layout

Bases: LayoutMixin, QtWidgets.QLayout

Source code in prettyqt\widgets\layout.py

class Layout(LayoutMixin, QtWidgets.QLayout):
    pass

LayoutItem

Bases: LayoutItemMixin, QtWidgets.QLayoutItem

Source code in prettyqt\widgets\layoutitem.py

class LayoutItem(LayoutItemMixin, QtWidgets.QLayoutItem):
    pass

LayoutItemMixin

Source code in prettyqt\widgets\layoutitem.py

class LayoutItemMixin:
    def __bool__(self):
        return not self.isEmpty()

    def set_alignment(self, alignment: constants.AlignmentStr):
        """Set the alignment of the layout.

        Args:
            alignment: alignment for the layout

        Raises:
            InvalidParamError: alignment does not exist
        """
        if alignment not in constants.ALIGNMENTS:
            raise InvalidParamError(alignment, constants.ALIGNMENTS)
        self.setAlignment(constants.ALIGNMENTS[alignment])

    def get_alignment(self) -> constants.AlignmentStr:
        """Return current alignment.

        Returns:
            alignment
        """
        return constants.ALIGNMENTS.inverse[self.alignment()]

    def get_item(
        self,
    ) -> QtWidgets.QWidget | QtWidgets.QLayout | QtWidgets.QSpacerItem | None:
        if content := self.widget():
            return content
        if content := self.layout():
            return content
        return content if (content := self.spacerItem()) else None

    def get_control_types(self) -> list[widgets.sizepolicy.ControlTypeStr]:
        return widgets.sizepolicy.CONTROL_TYPE.get_list(self.controlTypes())

    def get_expanding_directions(self) -> list[constants.OrientationStr]:
        return constants.ORIENTATION.get_list(self.expandingDirections())

__bool__()

Source code in prettyqt\widgets\layoutitem.py

def __bool__(self):
    return not self.isEmpty()

get_alignment() -> constants.AlignmentStr

Return current alignment.

Returns:

Type	Description
constants.AlignmentStr	alignment

Source code in prettyqt\widgets\layoutitem.py

def get_alignment(self) -> constants.AlignmentStr:
    """Return current alignment.

    Returns:
        alignment
    """
    return constants.ALIGNMENTS.inverse[self.alignment()]

get_control_types() -> list[widgets.sizepolicy.ControlTypeStr]

Source code in prettyqt\widgets\layoutitem.py

def get_control_types(self) -> list[widgets.sizepolicy.ControlTypeStr]:
    return widgets.sizepolicy.CONTROL_TYPE.get_list(self.controlTypes())

get_expanding_directions() -> list[constants.OrientationStr]

Source code in prettyqt\widgets\layoutitem.py

def get_expanding_directions(self) -> list[constants.OrientationStr]:
    return constants.ORIENTATION.get_list(self.expandingDirections())

get_item() -> QtWidgets.QWidget | QtWidgets.QLayout | QtWidgets.QSpacerItem | None

Source code in prettyqt\widgets\layoutitem.py

def get_item(
    self,
) -> QtWidgets.QWidget | QtWidgets.QLayout | QtWidgets.QSpacerItem | None:
    if content := self.widget():
        return content
    if content := self.layout():
        return content
    return content if (content := self.spacerItem()) else None

set_alignment(alignment: constants.AlignmentStr)

Set the alignment of the layout.

Parameters:

Name	Type	Description	Default
alignment	constants.AlignmentStr	alignment for the layout	required

Raises:

Type	Description
InvalidParamError	alignment does not exist

Source code in prettyqt\widgets\layoutitem.py

def set_alignment(self, alignment: constants.AlignmentStr):
    """Set the alignment of the layout.

    Args:
        alignment: alignment for the layout

    Raises:
        InvalidParamError: alignment does not exist
    """
    if alignment not in constants.ALIGNMENTS:
        raise InvalidParamError(alignment, constants.ALIGNMENTS)
    self.setAlignment(constants.ALIGNMENTS[alignment])

LayoutMixin

Bases: core.ObjectMixin, widgets.LayoutItemMixin

Source code in prettyqt\widgets\layout.py

class LayoutMixin(core.ObjectMixin, widgets.LayoutItemMixin):
    def __getitem__(
        self, index: str | int
    ) -> QtWidgets.QWidget | QtWidgets.QLayout | None:
        if isinstance(index, int):
            item = self.itemAt(index)
            widget = item.widget()
            if widget is None:
                widget = item.layout()
        elif isinstance(index, str):
            return self.find_child(typ=QtCore.QObject, name=index)
        return widget

    def __delitem__(self, index: int):
        item = self.itemAt(index)
        self.removeItem(item)

    def __len__(self) -> int:
        return self.count()

    def __repr__(self):
        return get_repr(self)

    def __iter__(self) -> Iterator[QtWidgets.QWidget | QtWidgets.QLayout | None]:
        return iter(self[i] for i in range(self.count()))

    def __contains__(self, item: QtWidgets.QWidget | QtWidgets.QLayoutItem):
        return self.indexOf(item) >= 0

    def serialize_fields(self):
        return dict(
            size_mode=self.get_size_mode(),
            spacing=self.spacing(),
            enabled=self.isEnabled(),
        )

    def get_children(self) -> list[QtWidgets.QWidget | QtWidgets.QLayout]:
        return list(self)

    def set_margin(self, margin: int):
        self.setContentsMargins(margin, margin, margin, margin)

    def set_spacing(self, pixels: int):
        self.setSpacing(pixels)

    @deprecated(reason="Use set_size_constraint instead")
    def set_size_mode(self, mode: SizeConstraintStr):
        self.set_size_constraint(mode)

    def set_size_constraint(self, mode: SizeConstraintStr):
        """Set the size mode of the layout.

        Args:
            mode: size mode for the layout

        Raises:
            InvalidParamError: size mode does not exist
        """
        if mode not in SIZE_CONSTRAINT:
            raise InvalidParamError(mode, SIZE_CONSTRAINT)
        self.setSizeConstraint(SIZE_CONSTRAINT[mode])

    @deprecated(reason="Use set_size_constraint instead")
    def get_size_mode(self) -> SizeConstraintStr:
        return self.get_size_constraint()

    def get_size_constraint(self) -> SizeConstraintStr:
        """Return current size mode.

        Returns:
            size mode
        """
        return SIZE_CONSTRAINT.inverse[self.sizeConstraint()]

    def set_alignment(
        self,
        alignment: constants.AlignmentStr,
        item: QtWidgets.QWidget | QtWidgets.QLayout | None = None,
    ) -> bool:
        """Set the alignment for widget / layout to alignment.

        Returns true if w is found in this layout (not including child layouts).

        Args:
            alignment: alignment for the layout
            item: set alignment for specific child only

        Raises:
            InvalidParamError: alignment does not exist
        """
        if alignment not in constants.ALIGNMENTS:
            raise InvalidParamError(alignment, constants.ALIGNMENTS)
        if item is not None:
            return self.setAlignment(item, constants.ALIGNMENTS[alignment])
        else:
            return self.setAlignment(constants.ALIGNMENTS[alignment])

    def add_widget(self, widget: QtWidgets.QWidget):
        self.addWidget(widget)

    def add(self, *items: QtWidgets.QWidget | QtWidgets.QLayout):
        for i in items:
            match i:
                case QtWidgets.QWidget():
                    self.addWidget(i)
                case QtWidgets.QLayout():
                    w = widgets.Widget()
                    w.set_layout(i)
                    self.addWidget(w)
                case _:
                    raise TypeError("add_item only supports widgets and layouts")

__contains__(item: QtWidgets.QWidget | QtWidgets.QLayoutItem)

Source code in prettyqt\widgets\layout.py

def __contains__(self, item: QtWidgets.QWidget | QtWidgets.QLayoutItem):
    return self.indexOf(item) >= 0

__delitem__(index: int)

Source code in prettyqt\widgets\layout.py

def __delitem__(self, index: int):
    item = self.itemAt(index)
    self.removeItem(item)

__getitem__(index: str | int) -> QtWidgets.QWidget | QtWidgets.QLayout | None

Source code in prettyqt\widgets\layout.py

def __getitem__(
    self, index: str | int
) -> QtWidgets.QWidget | QtWidgets.QLayout | None:
    if isinstance(index, int):
        item = self.itemAt(index)
        widget = item.widget()
        if widget is None:
            widget = item.layout()
    elif isinstance(index, str):
        return self.find_child(typ=QtCore.QObject, name=index)
    return widget

__iter__() -> Iterator[QtWidgets.QWidget | QtWidgets.QLayout | None]

Source code in prettyqt\widgets\layout.py

def __iter__(self) -> Iterator[QtWidgets.QWidget | QtWidgets.QLayout | None]:
    return iter(self[i] for i in range(self.count()))

__len__() -> int

Source code in prettyqt\widgets\layout.py

def __len__(self) -> int:
    return self.count()

__repr__()

Source code in prettyqt\widgets\layout.py

def __repr__(self):
    return get_repr(self)

add(*items: QtWidgets.QWidget | QtWidgets.QLayout)

Source code in prettyqt\widgets\layout.py

def add(self, *items: QtWidgets.QWidget | QtWidgets.QLayout):
    for i in items:
        match i:
            case QtWidgets.QWidget():
                self.addWidget(i)
            case QtWidgets.QLayout():
                w = widgets.Widget()
                w.set_layout(i)
                self.addWidget(w)
            case _:
                raise TypeError("add_item only supports widgets and layouts")

add_widget(widget: QtWidgets.QWidget)

Source code in prettyqt\widgets\layout.py

def add_widget(self, widget: QtWidgets.QWidget):
    self.addWidget(widget)

get_children() -> list[QtWidgets.QWidget | QtWidgets.QLayout]

Source code in prettyqt\widgets\layout.py

def get_children(self) -> list[QtWidgets.QWidget | QtWidgets.QLayout]:
    return list(self)

get_size_constraint() -> SizeConstraintStr

Return current size mode.

Returns:

Type	Description
SizeConstraintStr	size mode

Source code in prettyqt\widgets\layout.py

def get_size_constraint(self) -> SizeConstraintStr:
    """Return current size mode.

    Returns:
        size mode
    """
    return SIZE_CONSTRAINT.inverse[self.sizeConstraint()]

get_size_mode() -> SizeConstraintStr

Source code in prettyqt\widgets\layout.py

@deprecated(reason="Use set_size_constraint instead")
def get_size_mode(self) -> SizeConstraintStr:
    return self.get_size_constraint()

serialize_fields()

Source code in prettyqt\widgets\layout.py

def serialize_fields(self):
    return dict(
        size_mode=self.get_size_mode(),
        spacing=self.spacing(),
        enabled=self.isEnabled(),
    )

set_alignment(alignment: constants.AlignmentStr, item: QtWidgets.QWidget | QtWidgets.QLayout | None = None) -> bool

Set the alignment for widget / layout to alignment.

Returns true if w is found in this layout (not including child layouts).

Parameters:

Name	Type	Description	Default
alignment	constants.AlignmentStr	alignment for the layout	required
item	QtWidgets.QWidget | QtWidgets.QLayout | None	set alignment for specific child only	None

Raises:

Type	Description
InvalidParamError	alignment does not exist

Source code in prettyqt\widgets\layout.py

def set_alignment(
    self,
    alignment: constants.AlignmentStr,
    item: QtWidgets.QWidget | QtWidgets.QLayout | None = None,
) -> bool:
    """Set the alignment for widget / layout to alignment.

    Returns true if w is found in this layout (not including child layouts).

    Args:
        alignment: alignment for the layout
        item: set alignment for specific child only

    Raises:
        InvalidParamError: alignment does not exist
    """
    if alignment not in constants.ALIGNMENTS:
        raise InvalidParamError(alignment, constants.ALIGNMENTS)
    if item is not None:
        return self.setAlignment(item, constants.ALIGNMENTS[alignment])
    else:
        return self.setAlignment(constants.ALIGNMENTS[alignment])

set_margin(margin: int)

Source code in prettyqt\widgets\layout.py

def set_margin(self, margin: int):
    self.setContentsMargins(margin, margin, margin, margin)

set_size_constraint(mode: SizeConstraintStr)

Set the size mode of the layout.

Parameters:

Name	Type	Description	Default
mode	SizeConstraintStr	size mode for the layout	required

Raises:

Type	Description
InvalidParamError	size mode does not exist

Source code in prettyqt\widgets\layout.py

def set_size_constraint(self, mode: SizeConstraintStr):
    """Set the size mode of the layout.

    Args:
        mode: size mode for the layout

    Raises:
        InvalidParamError: size mode does not exist
    """
    if mode not in SIZE_CONSTRAINT:
        raise InvalidParamError(mode, SIZE_CONSTRAINT)
    self.setSizeConstraint(SIZE_CONSTRAINT[mode])

set_size_mode(mode: SizeConstraintStr)

Source code in prettyqt\widgets\layout.py

@deprecated(reason="Use set_size_constraint instead")
def set_size_mode(self, mode: SizeConstraintStr):
    self.set_size_constraint(mode)

set_spacing(pixels: int)

Source code in prettyqt\widgets\layout.py

def set_spacing(self, pixels: int):
    self.setSpacing(pixels)

LineEdit

Bases: widgets.WidgetMixin, QtWidgets.QLineEdit

Source code in prettyqt\widgets\lineedit.py

class LineEdit(widgets.WidgetMixin, QtWidgets.QLineEdit):
    value_changed = core.Signal(str)

    def __init__(
        self,
        default_value: str = "",
        read_only: bool = False,
        parent: QtWidgets.QWidget | None = None,
    ):
        super().__init__(default_value, parent)
        self.textChanged.connect(self._set_validation_color)
        self.textChanged.connect(self.value_changed)
        self.set_read_only(read_only)

    def __repr__(self):
        return get_repr(self, self.text())

    def __add__(self, other: str):
        self.append_text(other)
        return self

    def font(self) -> gui.Font:
        return gui.Font(super().font())

    def append_text(self, text: str):
        self.set_text(self.text() + text)

    def set_text(self, text: str):
        self.setText(text)

    def set_read_only(self, value: bool = True):
        """Set text to read-only.

        Args:
            value: True, for read-only, otherwise False
        """
        self.setReadOnly(value)

    def set_regex_validator(self, regex: str, flags=0) -> gui.RegularExpressionValidator:
        validator = gui.RegularExpressionValidator(self)
        validator.set_regex(regex, flags)
        self.set_validator(validator)
        return validator

    def set_range(self, lower: int | None, upper: int | None):
        val = gui.IntValidator()
        val.set_range(lower, upper)
        self.set_validator(val)

    def set_validator(self, validator: gui.Validator):
        self.setValidator(validator)
        self._set_validation_color()

    def set_input_mask(self, mask: str):
        match mask:
            case "ip_address":
                mask = "000.000.000.000;_"
            case "mac_address":
                mask = "HH:HH:HH:HH:HH:HH;_"
            case "iso_date":
                mask = "0000-00-00"
        self.setInputMask(mask)

    def _set_validation_color(self, state: bool = True):
        color = None if self.is_valid() else "orange"
        self.set_background_color(color)

    def set_echo_mode(self, mode: EchoModeStr):
        """Set echo mode.

        Args:
            mode: echo mode to use

        Raises:
            InvalidParamError: invalid echo mode
        """
        if mode not in ECHO_MODE:
            raise InvalidParamError(mode, ECHO_MODE)
        self.setEchoMode(ECHO_MODE[mode])

    def get_echo_mode(self) -> EchoModeStr:
        """Return echo mode.

        Returns:
            echo mode
        """
        return ECHO_MODE.inverse[self.echoMode()]

    def set_cursor_move_style(self, style: constants.CursorMoveStyleStr):
        """Set cursor move style.

        Args:
            style: cursor move style to use

        Raises:
            InvalidParamError: invalid cursor move style
        """
        if style not in constants.CURSOR_MOVE_STYLE:
            raise InvalidParamError(style, constants.CURSOR_MOVE_STYLE)
        self.setCursorMoveStyle(constants.CURSOR_MOVE_STYLE[style])

    def get_cursor_move_style(self) -> constants.CursorMoveStyleStr:
        """Return cursor move style.

        Returns:
            cursor move style
        """
        return constants.CURSOR_MOVE_STYLE.inverse[self.cursorMoveStyle()]

    def add_action(
        self, action: QtWidgets.QAction, position: ActionPositionStr = "trailing"
    ):
        self.addAction(action, ACTION_POSITION[position])

    def set_value(self, value: str):
        self.setText(value)

    def get_value(self) -> str:
        return self.text()

    def is_valid(self) -> bool:
        return self.hasAcceptableInput()

value_changed = core.Signal(str) class-attribute

__add__(other: str)

Source code in prettyqt\widgets\lineedit.py

def __add__(self, other: str):
    self.append_text(other)
    return self

__init__(default_value: str = '', read_only: bool = False, parent: QtWidgets.QWidget | None = None)

Source code in prettyqt\widgets\lineedit.py

def __init__(
    self,
    default_value: str = "",
    read_only: bool = False,
    parent: QtWidgets.QWidget | None = None,
):
    super().__init__(default_value, parent)
    self.textChanged.connect(self._set_validation_color)
    self.textChanged.connect(self.value_changed)
    self.set_read_only(read_only)

__repr__()

Source code in prettyqt\widgets\lineedit.py

def __repr__(self):
    return get_repr(self, self.text())

add_action(action: QtWidgets.QAction, position: ActionPositionStr = 'trailing')

Source code in prettyqt\widgets\lineedit.py

def add_action(
    self, action: QtWidgets.QAction, position: ActionPositionStr = "trailing"
):
    self.addAction(action, ACTION_POSITION[position])

append_text(text: str)

Source code in prettyqt\widgets\lineedit.py

def append_text(self, text: str):
    self.set_text(self.text() + text)

font() -> gui.Font

Source code in prettyqt\widgets\lineedit.py

def font(self) -> gui.Font:
    return gui.Font(super().font())

get_cursor_move_style() -> constants.CursorMoveStyleStr

Return cursor move style.

Returns:

Type	Description
constants.CursorMoveStyleStr	cursor move style

Source code in prettyqt\widgets\lineedit.py

def get_cursor_move_style(self) -> constants.CursorMoveStyleStr:
    """Return cursor move style.

    Returns:
        cursor move style
    """
    return constants.CURSOR_MOVE_STYLE.inverse[self.cursorMoveStyle()]

get_echo_mode() -> EchoModeStr

Return echo mode.

Returns:

Type	Description
EchoModeStr	echo mode

Source code in prettyqt\widgets\lineedit.py

def get_echo_mode(self) -> EchoModeStr:
    """Return echo mode.

    Returns:
        echo mode
    """
    return ECHO_MODE.inverse[self.echoMode()]

get_value() -> str

Source code in prettyqt\widgets\lineedit.py

def get_value(self) -> str:
    return self.text()

is_valid() -> bool

Source code in prettyqt\widgets\lineedit.py

def is_valid(self) -> bool:
    return self.hasAcceptableInput()

set_cursor_move_style(style: constants.CursorMoveStyleStr)

Set cursor move style.

Parameters:

Name	Type	Description	Default
style	constants.CursorMoveStyleStr	cursor move style to use	required

Raises:

Type	Description
InvalidParamError	invalid cursor move style

Source code in prettyqt\widgets\lineedit.py

def set_cursor_move_style(self, style: constants.CursorMoveStyleStr):
    """Set cursor move style.

    Args:
        style: cursor move style to use

    Raises:
        InvalidParamError: invalid cursor move style
    """
    if style not in constants.CURSOR_MOVE_STYLE:
        raise InvalidParamError(style, constants.CURSOR_MOVE_STYLE)
    self.setCursorMoveStyle(constants.CURSOR_MOVE_STYLE[style])

set_echo_mode(mode: EchoModeStr)

Set echo mode.

Parameters:

Name	Type	Description	Default
mode	EchoModeStr	echo mode to use	required

Raises:

Type	Description
InvalidParamError	invalid echo mode

Source code in prettyqt\widgets\lineedit.py

def set_echo_mode(self, mode: EchoModeStr):
    """Set echo mode.

    Args:
        mode: echo mode to use

    Raises:
        InvalidParamError: invalid echo mode
    """
    if mode not in ECHO_MODE:
        raise InvalidParamError(mode, ECHO_MODE)
    self.setEchoMode(ECHO_MODE[mode])

set_input_mask(mask: str)

Source code in prettyqt\widgets\lineedit.py

def set_input_mask(self, mask: str):
    match mask:
        case "ip_address":
            mask = "000.000.000.000;_"
        case "mac_address":
            mask = "HH:HH:HH:HH:HH:HH;_"
        case "iso_date":
            mask = "0000-00-00"
    self.setInputMask(mask)

set_range(lower: int | None, upper: int | None)

Source code in prettyqt\widgets\lineedit.py

def set_range(self, lower: int | None, upper: int | None):
    val = gui.IntValidator()
    val.set_range(lower, upper)
    self.set_validator(val)

set_read_only(value: bool = True)

Set text to read-only.

Parameters:

Name	Type	Description	Default
value	bool	True, for read-only, otherwise False	True

Source code in prettyqt\widgets\lineedit.py

def set_read_only(self, value: bool = True):
    """Set text to read-only.

    Args:
        value: True, for read-only, otherwise False
    """
    self.setReadOnly(value)

set_regex_validator(regex: str, flags = 0) -> gui.RegularExpressionValidator

Source code in prettyqt\widgets\lineedit.py

def set_regex_validator(self, regex: str, flags=0) -> gui.RegularExpressionValidator:
    validator = gui.RegularExpressionValidator(self)
    validator.set_regex(regex, flags)
    self.set_validator(validator)
    return validator

set_text(text: str)

Source code in prettyqt\widgets\lineedit.py

def set_text(self, text: str):
    self.setText(text)

set_validator(validator: gui.Validator)

Source code in prettyqt\widgets\lineedit.py

def set_validator(self, validator: gui.Validator):
    self.setValidator(validator)
    self._set_validation_color()

set_value(value: str)

Source code in prettyqt\widgets\lineedit.py

def set_value(self, value: str):
    self.setText(value)

ListView

Bases: ListViewMixin, QtWidgets.QListView

Source code in prettyqt\widgets\listview.py

class ListView(ListViewMixin, QtWidgets.QListView):
    pass

ListViewMixin

Bases: widgets.AbstractItemViewMixin

Source code in prettyqt\widgets\listview.py

class ListViewMixin(widgets.AbstractItemViewMixin):
    def set_view_mode(self, mode: ViewModeStr):
        """Set view mode.

        Args:
            mode: view mode to use

        Raises:
            InvalidParamError: invalid view mode
        """
        if mode not in VIEW_MODE:
            raise InvalidParamError(mode, VIEW_MODE)
        self.setViewMode(VIEW_MODE[mode])

    def get_view_mode(self) -> ViewModeStr:
        """Return view mode.

        Returns:
            view mode
        """
        return VIEW_MODE.inverse[self.viewMode()]

    def set_resize_mode(self, mode: ResizeModeStr):
        """Set resize mode.

        Args:
            mode: resize mode to use

        Raises:
            InvalidParamError: invalid resize mode
        """
        if mode not in RESIZE_MODE:
            raise InvalidParamError(mode, RESIZE_MODE)
        self.setResizeMode(RESIZE_MODE[mode])

    def get_resize_mode(self) -> ResizeModeStr:
        """Return resize mode.

        Returns:
            resize mode
        """
        return RESIZE_MODE.inverse[self.resizeMode()]

    def set_layout_mode(self, mode: LayoutModeStr):
        """Set layout mode.

        Args:
            mode: layout mode to use

        Raises:
            InvalidParamError: invalid layout mode
        """
        if mode not in LAYOUT_MODE:
            raise InvalidParamError(mode, LAYOUT_MODE)
        self.setLayoutMode(LAYOUT_MODE[mode])

    def get_layout_mode(self) -> LayoutModeStr:
        """Return layout mode.

        Returns:
            layout mode
        """
        return LAYOUT_MODE.inverse[self.layoutMode()]

    def set_movement(self, mode: MovementStr):
        """Set movement mode.

        Args:
            mode: movement mode to use

        Raises:
            InvalidParamError: invalid movement mode
        """
        if mode not in MOVEMENT:
            raise InvalidParamError(mode, MOVEMENT)
        self.setMovement(MOVEMENT[mode])

    def get_movement(self) -> MovementStr:
        """Return movement mode.

        Returns:
            movement mode
        """
        return MOVEMENT.inverse[self.movement()]

    def set_flow(self, mode: FlowStr):
        """Set flow mode.

        Args:
            mode: flow mode to use

        Raises:
            InvalidParamError: invalid flow mode
        """
        if mode not in FLOW:
            raise InvalidParamError(mode, FLOW)
        self.setFlow(FLOW[mode])

    def get_flow(self) -> FlowStr:
        """Return flow mode.

        Returns:
            flow mode
        """
        return FLOW.inverse[self.flow()]

    def set_grid_size(self, size: QtCore.QSize | tuple[int, int]):
        if isinstance(size, tuple):
            size = QtCore.QSize(*size)
        self.setGridSize(size)

    def get_grid_size(self) -> core.Size:
        return core.Size(self.gridSize())

get_flow() -> FlowStr

Return flow mode.

Returns:

Type	Description
FlowStr	flow mode

Source code in prettyqt\widgets\listview.py

def get_flow(self) -> FlowStr:
    """Return flow mode.

    Returns:
        flow mode
    """
    return FLOW.inverse[self.flow()]

get_grid_size() -> core.Size

Source code in prettyqt\widgets\listview.py

def get_grid_size(self) -> core.Size:
    return core.Size(self.gridSize())

get_layout_mode() -> LayoutModeStr

Return layout mode.

Returns:

Type	Description
LayoutModeStr	layout mode

Source code in prettyqt\widgets\listview.py

def get_layout_mode(self) -> LayoutModeStr:
    """Return layout mode.

    Returns:
        layout mode
    """
    return LAYOUT_MODE.inverse[self.layoutMode()]

get_movement() -> MovementStr

Return movement mode.

Returns:

Type	Description
MovementStr	movement mode

Source code in prettyqt\widgets\listview.py

def get_movement(self) -> MovementStr:
    """Return movement mode.

    Returns:
        movement mode
    """
    return MOVEMENT.inverse[self.movement()]

get_resize_mode() -> ResizeModeStr

Return resize mode.

Returns:

Type	Description
ResizeModeStr	resize mode

Source code in prettyqt\widgets\listview.py

def get_resize_mode(self) -> ResizeModeStr:
    """Return resize mode.

    Returns:
        resize mode
    """
    return RESIZE_MODE.inverse[self.resizeMode()]

get_view_mode() -> ViewModeStr

Return view mode.

Returns:

Type	Description
ViewModeStr	view mode

Source code in prettyqt\widgets\listview.py

def get_view_mode(self) -> ViewModeStr:
    """Return view mode.

    Returns:
        view mode
    """
    return VIEW_MODE.inverse[self.viewMode()]

set_flow(mode: FlowStr)

Set flow mode.

Parameters:

Name	Type	Description	Default
mode	FlowStr	flow mode to use	required

Raises:

Type	Description
InvalidParamError	invalid flow mode

Source code in prettyqt\widgets\listview.py

def set_flow(self, mode: FlowStr):
    """Set flow mode.

    Args:
        mode: flow mode to use

    Raises:
        InvalidParamError: invalid flow mode
    """
    if mode not in FLOW:
        raise InvalidParamError(mode, FLOW)
    self.setFlow(FLOW[mode])

set_grid_size(size: QtCore.QSize | tuple[int, int])

Source code in prettyqt\widgets\listview.py

def set_grid_size(self, size: QtCore.QSize | tuple[int, int]):
    if isinstance(size, tuple):
        size = QtCore.QSize(*size)
    self.setGridSize(size)

set_layout_mode(mode: LayoutModeStr)

Set layout mode.

Parameters:

Name	Type	Description	Default
mode	LayoutModeStr	layout mode to use	required

Raises:

Type	Description
InvalidParamError	invalid layout mode

Source code in prettyqt\widgets\listview.py

def set_layout_mode(self, mode: LayoutModeStr):
    """Set layout mode.

    Args:
        mode: layout mode to use

    Raises:
        InvalidParamError: invalid layout mode
    """
    if mode not in LAYOUT_MODE:
        raise InvalidParamError(mode, LAYOUT_MODE)
    self.setLayoutMode(LAYOUT_MODE[mode])

set_movement(mode: MovementStr)

Set movement mode.

Parameters:

Name	Type	Description	Default
mode	MovementStr	movement mode to use	required

Raises:

Type	Description
InvalidParamError	invalid movement mode

Source code in prettyqt\widgets\listview.py

def set_movement(self, mode: MovementStr):
    """Set movement mode.

    Args:
        mode: movement mode to use

    Raises:
        InvalidParamError: invalid movement mode
    """
    if mode not in MOVEMENT:
        raise InvalidParamError(mode, MOVEMENT)
    self.setMovement(MOVEMENT[mode])

set_resize_mode(mode: ResizeModeStr)

Set resize mode.

Parameters:

Name	Type	Description	Default
mode	ResizeModeStr	resize mode to use	required

Raises:

Type	Description
InvalidParamError	invalid resize mode

Source code in prettyqt\widgets\listview.py

def set_resize_mode(self, mode: ResizeModeStr):
    """Set resize mode.

    Args:
        mode: resize mode to use

    Raises:
        InvalidParamError: invalid resize mode
    """
    if mode not in RESIZE_MODE:
        raise InvalidParamError(mode, RESIZE_MODE)
    self.setResizeMode(RESIZE_MODE[mode])

set_view_mode(mode: ViewModeStr)

Set view mode.

Parameters:

Name	Type	Description	Default
mode	ViewModeStr	view mode to use	required

Raises:

Type	Description
InvalidParamError	invalid view mode

Source code in prettyqt\widgets\listview.py

def set_view_mode(self, mode: ViewModeStr):
    """Set view mode.

    Args:
        mode: view mode to use

    Raises:
        InvalidParamError: invalid view mode
    """
    if mode not in VIEW_MODE:
        raise InvalidParamError(mode, VIEW_MODE)
    self.setViewMode(VIEW_MODE[mode])

ListWidget

Bases: widgets.ListViewMixin, QtWidgets.QListWidget

Source code in prettyqt\widgets\listwidget.py

class ListWidget(widgets.ListViewMixin, QtWidgets.QListWidget):
    value_changed = core.Signal(object)

    def __init__(
        self, parent: QtWidgets.QWidget | None = None, selection_mode: str = "single"
    ):
        super().__init__(parent)
        self.itemSelectionChanged.connect(self.on_index_change)
        self.set_selection_mode(selection_mode)

    def __repr__(self):
        return f"{type(self).__name__}: {self.count()} items"

    def __getitem__(self, row: int) -> QtWidgets.QListWidgetItem:
        item = self.item(row)
        if item is None:
            raise KeyError(row)
        return item

    def __delitem__(self, row: int):
        self.takeItem(row)

    def __add__(self, other: QtWidgets.QListWidgetItem):
        self.addItem(other)
        return self

    def __iter__(self) -> Iterator[QtWidgets.QListWidgetItem]:
        return iter(self.get_children())

    def __len__(self) -> int:
        return self.count()

    # def __setstate__(self, state):
    #     self.set_selection_mode(state["selection_mode"])
    #     self.setSortingEnabled(state["sorting_enabled"])
    #     self.setCurrentRow(state["current_row"])
    #     for item in state["items"]:
    #         self.addItem(item)

    # def __reduce__(self):
    #     return type(self), (), self.__getstate__()

    # def serialize_fields(self):
    #     return dict(
    #         items=self.get_children(),
    #         selection_mode=self.get_selection_mode(),
    #         sorting_enabled=self.isSortingEnabled(),
    #         current_row=self.currentRow(),
    #     )

    def sort(self, reverse: bool = False):
        order = constants.DESCENDING if reverse else constants.ASCENDING
        self.sortItems(order)

    def on_index_change(self):
        data = self.get_value()
        self.value_changed.emit(data)

    def get_children(self) -> list[QtWidgets.QListWidgetItem]:
        return [self.item(row) for row in range(self.count())]

    def add_items(self, items: Iterable | Mapping):
        if isinstance(items, Mapping):
            for k, v in items.items():
                self.add(v, k)
        else:
            for i in items:
                if isinstance(i, tuple | list):
                    self.add(*i)
                else:
                    self.add(i)

    def add_item(
        self,
        name: str = "",
        icon: datatypes.IconType = None,
        data: dict | None = None,
        foreground: QtGui.QBrush | None = None,
        background: QtGui.QBrush | None = None,
        font: QtGui.QFont | None = None,
        selected: bool = None,
        status_tip: str | None = None,
        tool_tip: str | None = None,
        whats_this: str | None = None,
        # text_alignment: Optional[str] = None,
        checkstate: constants.StateStr | None = None,
        flags: QtCore.Qt.ItemFlag | None = None,
        size_hint: datatypes.SizeType | None = None,
        is_user_type: bool = False,
    ) -> widgets.ListWidgetItem:
        typ = 1 if is_user_type else 0
        item = widgets.ListWidgetItem(name, self, typ)
        if icon is not None:
            icon = iconprovider.get_icon(icon)
            item.setIcon(icon)
        if data is not None:
            for k, v in data.items():
                item.setData(k, v)
        if foreground is not None:
            item.setForeground(foreground)
        if background is not None:
            item.setBackground(background)
        if font is not None:
            item.setFont(font)
        if flags is not None:
            item.setFlags(flags)
        if selected:
            item.setSelected(selected)
        if status_tip:
            item.setStatusTip(status_tip)
        if tool_tip:
            item.setToolTip(tool_tip)
        if whats_this:
            item.setWhatsThis(whats_this)
        if size_hint is not None:
            item.set_size_hint(size_hint)
        if checkstate is not None:
            item.set_checkstate(checkstate)
        self.addItem(item)
        return item

    def add(self, label: str, data=NoData, icon: datatypes.IconType = None):
        if data is NoData:
            data = label
        item = widgets.ListWidgetItem(label)
        item.set_icon(icon)
        item.setData(constants.USER_ROLE, data)  # type: ignore
        self.addItem(item)

    def get_value(self) -> list[Any]:
        return [i.data(constants.USER_ROLE) for i in self.selectedItems()]  # type: ignore

    def set_value(self, value):
        for i in self.get_children():
            if i.data(constants.USER_ROLE) in value:  # type: ignore
                self.setCurrentItem(i)
                break

    def scroll_to_item(
        self,
        item: QtWidgets.QListWidgetItem,
        mode: widgets.abstractitemview.ScrollHintStr = "ensure_visible",
    ):
        if mode not in widgets.abstractitemview.SCROLL_HINT:
            raise InvalidParamError(mode, widgets.abstractitemview.SCROLL_HINT)
        self.scrollToItem(item, widgets.abstractitemview.SCROLL_HINT[mode])

    def find_items(
        self, text: str, column: int = 0, mode: constants.MatchFlagStr = "exact"
    ) -> list[QtGui.QStandardItem]:
        if mode not in constants.MATCH_FLAGS:
            raise InvalidParamError(mode, constants.MATCH_FLAGS)
        return self.findItems(text, constants.MATCH_FLAGS[mode], column)  # type: ignore

value_changed = core.Signal(object) class-attribute

__add__(other: QtWidgets.QListWidgetItem)

Source code in prettyqt\widgets\listwidget.py

def __add__(self, other: QtWidgets.QListWidgetItem):
    self.addItem(other)
    return self

__delitem__(row: int)

Source code in prettyqt\widgets\listwidget.py

def __delitem__(self, row: int):
    self.takeItem(row)

__getitem__(row: int) -> QtWidgets.QListWidgetItem

Source code in prettyqt\widgets\listwidget.py

def __getitem__(self, row: int) -> QtWidgets.QListWidgetItem:
    item = self.item(row)
    if item is None:
        raise KeyError(row)
    return item

__init__(parent: QtWidgets.QWidget | None = None, selection_mode: str = 'single')

Source code in prettyqt\widgets\listwidget.py

def __init__(
    self, parent: QtWidgets.QWidget | None = None, selection_mode: str = "single"
):
    super().__init__(parent)
    self.itemSelectionChanged.connect(self.on_index_change)
    self.set_selection_mode(selection_mode)

__iter__() -> Iterator[QtWidgets.QListWidgetItem]

Source code in prettyqt\widgets\listwidget.py

def __iter__(self) -> Iterator[QtWidgets.QListWidgetItem]:
    return iter(self.get_children())

__len__() -> int

Source code in prettyqt\widgets\listwidget.py

def __len__(self) -> int:
    return self.count()

__repr__()

Source code in prettyqt\widgets\listwidget.py

def __repr__(self):
    return f"{type(self).__name__}: {self.count()} items"

add(label: str, data = NoData, icon: datatypes.IconType = None)

Source code in prettyqt\widgets\listwidget.py

def add(self, label: str, data=NoData, icon: datatypes.IconType = None):
    if data is NoData:
        data = label
    item = widgets.ListWidgetItem(label)
    item.set_icon(icon)
    item.setData(constants.USER_ROLE, data)  # type: ignore
    self.addItem(item)

add_item(name: str = '', icon: datatypes.IconType = None, data: dict | None = None, foreground: QtGui.QBrush | None = None, background: QtGui.QBrush | None = None, font: QtGui.QFont | None = None, selected: bool = None, status_tip: str | None = None, tool_tip: str | None = None, whats_this: str | None = None, checkstate: constants.StateStr | None = None, flags: QtCore.Qt.ItemFlag | None = None, size_hint: datatypes.SizeType | None = None, is_user_type: bool = False) -> widgets.ListWidgetItem

Source code in prettyqt\widgets\listwidget.py

def add_item(
    self,
    name: str = "",
    icon: datatypes.IconType = None,
    data: dict | None = None,
    foreground: QtGui.QBrush | None = None,
    background: QtGui.QBrush | None = None,
    font: QtGui.QFont | None = None,
    selected: bool = None,
    status_tip: str | None = None,
    tool_tip: str | None = None,
    whats_this: str | None = None,
    # text_alignment: Optional[str] = None,
    checkstate: constants.StateStr | None = None,
    flags: QtCore.Qt.ItemFlag | None = None,
    size_hint: datatypes.SizeType | None = None,
    is_user_type: bool = False,
) -> widgets.ListWidgetItem:
    typ = 1 if is_user_type else 0
    item = widgets.ListWidgetItem(name, self, typ)
    if icon is not None:
        icon = iconprovider.get_icon(icon)
        item.setIcon(icon)
    if data is not None:
        for k, v in data.items():
            item.setData(k, v)
    if foreground is not None:
        item.setForeground(foreground)
    if background is not None:
        item.setBackground(background)
    if font is not None:
        item.setFont(font)
    if flags is not None:
        item.setFlags(flags)
    if selected:
        item.setSelected(selected)
    if status_tip:
        item.setStatusTip(status_tip)
    if tool_tip:
        item.setToolTip(tool_tip)
    if whats_this:
        item.setWhatsThis(whats_this)
    if size_hint is not None:
        item.set_size_hint(size_hint)
    if checkstate is not None:
        item.set_checkstate(checkstate)
    self.addItem(item)
    return item

add_items(items: Iterable | Mapping)

Source code in prettyqt\widgets\listwidget.py

def add_items(self, items: Iterable | Mapping):
    if isinstance(items, Mapping):
        for k, v in items.items():
            self.add(v, k)
    else:
        for i in items:
            if isinstance(i, tuple | list):
                self.add(*i)
            else:
                self.add(i)

find_items(text: str, column: int = 0, mode: constants.MatchFlagStr = 'exact') -> list[QtGui.QStandardItem]

Source code in prettyqt\widgets\listwidget.py

def find_items(
    self, text: str, column: int = 0, mode: constants.MatchFlagStr = "exact"
) -> list[QtGui.QStandardItem]:
    if mode not in constants.MATCH_FLAGS:
        raise InvalidParamError(mode, constants.MATCH_FLAGS)
    return self.findItems(text, constants.MATCH_FLAGS[mode], column)  # type: ignore

get_children() -> list[QtWidgets.QListWidgetItem]

Source code in prettyqt\widgets\listwidget.py

def get_children(self) -> list[QtWidgets.QListWidgetItem]:
    return [self.item(row) for row in range(self.count())]

get_value() -> list[Any]

Source code in prettyqt\widgets\listwidget.py

def get_value(self) -> list[Any]:
    return [i.data(constants.USER_ROLE) for i in self.selectedItems()]  # type: ignore

on_index_change()

Source code in prettyqt\widgets\listwidget.py

def on_index_change(self):
    data = self.get_value()
    self.value_changed.emit(data)

scroll_to_item(item: QtWidgets.QListWidgetItem, mode: widgets.abstractitemview.ScrollHintStr = 'ensure_visible')

Source code in prettyqt\widgets\listwidget.py

def scroll_to_item(
    self,
    item: QtWidgets.QListWidgetItem,
    mode: widgets.abstractitemview.ScrollHintStr = "ensure_visible",
):
    if mode not in widgets.abstractitemview.SCROLL_HINT:
        raise InvalidParamError(mode, widgets.abstractitemview.SCROLL_HINT)
    self.scrollToItem(item, widgets.abstractitemview.SCROLL_HINT[mode])

set_value(value)

Source code in prettyqt\widgets\listwidget.py

def set_value(self, value):
    for i in self.get_children():
        if i.data(constants.USER_ROLE) in value:  # type: ignore
            self.setCurrentItem(i)
            break

sort(reverse: bool = False)

Source code in prettyqt\widgets\listwidget.py

def sort(self, reverse: bool = False):
    order = constants.DESCENDING if reverse else constants.ASCENDING
    self.sortItems(order)

ListWidgetItem

Bases: serializemixin.SerializeMixin, QtWidgets.QListWidgetItem

Source code in prettyqt\widgets\listwidgetitem.py

class ListWidgetItem(serializemixin.SerializeMixin, QtWidgets.QListWidgetItem):
    def __repr__(self):
        return get_repr(self, self.icon(), self.text())

    def __setitem__(self, index: int, value):
        self.setData(index, value)

    def __getitem__(self, index: int):
        return self.data(index)

    def serialize_fields(self):
        return dict(
            text=self.text(),
            tool_tip=self.toolTip(),
            status_tip=self.statusTip(),
            checkstate=self.get_checkstate(),
            icon=self.get_icon(),
            data=self.data(constants.USER_ROLE),  # type: ignore
        )

    def set_icon(self, icon: datatypes.IconType):
        """Set the icon for the action.

        Args:
            icon: icon to use
        """
        icon = iconprovider.get_icon(icon)
        self.setIcon(icon)

    def set_checkstate(self, state: constants.StateStr):
        """Set checkstate of the checkbox.

        Args:
            state: checkstate to use

        Raises:
            InvalidParamError: invalid checkstate
        """
        if state not in constants.STATE:
            raise InvalidParamError(state, constants.STATE)
        self.setCheckState(constants.STATE[state])

    def get_checkstate(self) -> constants.StateStr:
        """Return checkstate.

        Returns:
            checkstate
        """
        return constants.STATE.inverse[self.checkState()]

    def get_background(self) -> gui.Brush:
        return gui.Brush(self.background())

    def get_foreground(self) -> gui.Brush:
        return gui.Brush(self.foreground())

    def get_font(self) -> gui.Font:
        return gui.Font(self.font())

    def get_icon(self) -> gui.Icon | None:
        icon = self.icon()
        return None if icon.isNull() else gui.Icon(icon)

    def set_data(self, role: str, data):
        role_id = constants.ITEM_DATA_ROLE[role]
        self.setData(role_id, data)

    def set_size_hint(self, hint: datatypes.SizeType):
        if isinstance(hint, tuple):
            hint = QtCore.QSize(*hint)
        self.setSizeHint(hint)

    def set_text_alignment(
        self,
        horizontal: constants.HorizontalAlignmentStr | None = None,
        vertical: constants.VerticalAlignmentStr | None = None,
    ):
        """Set text alignment of the checkbox.

        Args:
            horizontal: horizontal text alignment to use
            vertical: vertical text alignment to use

        Raises:
            InvalidParamError: invalid text alignment
        """
        match horizontal, vertical:
            case None, None:
                return
            case None, _:
                flag = constants.V_ALIGNMENT[vertical]
            case _, None:
                flag = constants.H_ALIGNMENT[horizontal]
            case _, _:
                flag = constants.V_ALIGNMENT[vertical] | constants.H_ALIGNMENT[horizontal]
        self.setTextAlignment(flag)

__getitem__(index: int)

Source code in prettyqt\widgets\listwidgetitem.py

def __getitem__(self, index: int):
    return self.data(index)

__repr__()

Source code in prettyqt\widgets\listwidgetitem.py

def __repr__(self):
    return get_repr(self, self.icon(), self.text())

__setitem__(index: int, value)

Source code in prettyqt\widgets\listwidgetitem.py

def __setitem__(self, index: int, value):
    self.setData(index, value)

get_background() -> gui.Brush

Source code in prettyqt\widgets\listwidgetitem.py

def get_background(self) -> gui.Brush:
    return gui.Brush(self.background())

get_checkstate() -> constants.StateStr

Return checkstate.

Returns:

Type	Description
constants.StateStr	checkstate

Source code in prettyqt\widgets\listwidgetitem.py

def get_checkstate(self) -> constants.StateStr:
    """Return checkstate.

    Returns:
        checkstate
    """
    return constants.STATE.inverse[self.checkState()]

get_font() -> gui.Font

Source code in prettyqt\widgets\listwidgetitem.py

def get_font(self) -> gui.Font:
    return gui.Font(self.font())

get_foreground() -> gui.Brush

Source code in prettyqt\widgets\listwidgetitem.py

def get_foreground(self) -> gui.Brush:
    return gui.Brush(self.foreground())

get_icon() -> gui.Icon | None

Source code in prettyqt\widgets\listwidgetitem.py

def get_icon(self) -> gui.Icon | None:
    icon = self.icon()
    return None if icon.isNull() else gui.Icon(icon)

serialize_fields()

Source code in prettyqt\widgets\listwidgetitem.py

def serialize_fields(self):
    return dict(
        text=self.text(),
        tool_tip=self.toolTip(),
        status_tip=self.statusTip(),
        checkstate=self.get_checkstate(),
        icon=self.get_icon(),
        data=self.data(constants.USER_ROLE),  # type: ignore
    )

set_checkstate(state: constants.StateStr)

Set checkstate of the checkbox.

Parameters:

Name	Type	Description	Default
state	constants.StateStr	checkstate to use	required

Raises:

Type	Description
InvalidParamError	invalid checkstate

Source code in prettyqt\widgets\listwidgetitem.py

def set_checkstate(self, state: constants.StateStr):
    """Set checkstate of the checkbox.

    Args:
        state: checkstate to use

    Raises:
        InvalidParamError: invalid checkstate
    """
    if state not in constants.STATE:
        raise InvalidParamError(state, constants.STATE)
    self.setCheckState(constants.STATE[state])

set_data(role: str, data)

Source code in prettyqt\widgets\listwidgetitem.py

def set_data(self, role: str, data):
    role_id = constants.ITEM_DATA_ROLE[role]
    self.setData(role_id, data)

set_icon(icon: datatypes.IconType)

Set the icon for the action.

Parameters:

Name	Type	Description	Default
icon	datatypes.IconType	icon to use	required

Source code in prettyqt\widgets\listwidgetitem.py

def set_icon(self, icon: datatypes.IconType):
    """Set the icon for the action.

    Args:
        icon: icon to use
    """
    icon = iconprovider.get_icon(icon)
    self.setIcon(icon)

set_size_hint(hint: datatypes.SizeType)

Source code in prettyqt\widgets\listwidgetitem.py

def set_size_hint(self, hint: datatypes.SizeType):
    if isinstance(hint, tuple):
        hint = QtCore.QSize(*hint)
    self.setSizeHint(hint)

set_text_alignment(horizontal: constants.HorizontalAlignmentStr | None = None, vertical: constants.VerticalAlignmentStr | None = None)

Set text alignment of the checkbox.

Parameters:

Name	Type	Description	Default
horizontal	constants.HorizontalAlignmentStr | None	horizontal text alignment to use	None
vertical	constants.VerticalAlignmentStr | None	vertical text alignment to use	None

Raises:

Type	Description
InvalidParamError	invalid text alignment

Source code in prettyqt\widgets\listwidgetitem.py

def set_text_alignment(
    self,
    horizontal: constants.HorizontalAlignmentStr | None = None,
    vertical: constants.VerticalAlignmentStr | None = None,
):
    """Set text alignment of the checkbox.

    Args:
        horizontal: horizontal text alignment to use
        vertical: vertical text alignment to use

    Raises:
        InvalidParamError: invalid text alignment
    """
    match horizontal, vertical:
        case None, None:
            return
        case None, _:
            flag = constants.V_ALIGNMENT[vertical]
        case _, None:
            flag = constants.H_ALIGNMENT[horizontal]
        case _, _:
            flag = constants.V_ALIGNMENT[vertical] | constants.H_ALIGNMENT[horizontal]
    self.setTextAlignment(flag)

MainWindow

Bases: widgets.WidgetMixin, QtWidgets.QMainWindow

Class for our mainWindow.

Includes all docks, a centralwidget and a toolbar

Source code in prettyqt\widgets\mainwindow.py

class MainWindow(widgets.WidgetMixin, QtWidgets.QMainWindow):
    """Class for our mainWindow.

    Includes all docks, a centralwidget and a toolbar
    """

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.setMenuBar(widgets.MenuBar())
        self.setDockOptions(
            self.DockOption.AllowTabbedDocks  # type: ignore
            | self.DockOption.AllowNestedDocks
            | self.DockOption.GroupedDragging
            | self.DockOption.AnimatedDocks
        )

    def __getitem__(self, index: str) -> QtWidgets.QWidget:
        result = self.find_child(QtWidgets.QWidget, index)
        if result is None:
            raise KeyError("Widget not found")
        return result

    def set_widget(self, widget: QtWidgets.QWidget | None):
        if widget is None:
            self.takeCentralWidget()
        else:
            self.setCentralWidget(widget)

    def createPopupMenu(self) -> widgets.Menu:
        # qactions = self.createPopupMenu()
        menu = widgets.Menu(parent=self)
        for i, item in enumerate(self.get_docks()):
            action = widgets.Action(text=item.windowTitle(), parent=self)
            action.set_checkable(True)
            action.set_checked(item.isVisible())
            action.set_shortcut(f"Ctrl+Shift+{i}")
            action.set_shortcut_context("application")
            action.toggled.connect(item.setVisible)
            menu.add(action)
        menu.add_separator()
        for tb in self.get_toolbars():
            action = widgets.Action(text=tb.windowTitle(), parent=self)
            action.set_checkable(True)
            action.toggled.connect(tb.setVisible)
            action.set_checked(tb.isVisible())
            menu.add(action)
        return menu

    def add_toolbar(
        self, toolbar: QtWidgets.QToolBar, position: constants.ToolbarAreaStr = "top"
    ):
        """Adds a toolbar to the mainmenu at specified area.

        Args:
            toolbar: toolbar to use
            position: position of the toolbar

        Raises:
            InvalidParamError: position does not exist
        """
        if position not in constants.TOOLBAR_AREA:
            raise InvalidParamError(position, constants.TOOLBAR_AREA)
        self.addToolBar(constants.TOOLBAR_AREA[position], toolbar)

    def add_toolbar_break(self, position: constants.ToolbarAreaStr = "top"):
        """Adds a toolbar break to the given area behind the last item.

        Args:
            position: position of the toolbar

        Raises:
            InvalidParamError: position does not exist
        """
        if position not in constants.TOOLBAR_AREA:
            raise InvalidParamError(position, constants.TOOLBAR_AREA)
        self.addToolBarBreak(constants.TOOLBAR_AREA[position])

    def load_window_state(self, recursive: bool = False) -> bool:
        settings = core.Settings()
        name = self.get_id()
        geom = settings.get(f"{name}.geometry")
        state = settings.get(f"{name}.state")
        restored = False
        if geom is not None and state is not None:
            try:
                logger.debug(f"Loading window state for {self.windowTitle()!r}...")
                self.restoreGeometry(geom)
                if isinstance(state, str):
                    state = state.encode()
                self.restoreState(state)
                restored = True
            except TypeError:
                logger.error("Wrong type for window state. Probably Qt binding switch?")
        if recursive:
            for window in self.find_children(MainWindow, recursive=True):
                if window.get_id():
                    window.load_window_state()
        return restored

    def save_window_state(self, recursive: bool = False):
        """Save current window state as QSetting.

        Args:
            recursive (bool, optional): Description
        """
        settings = core.Settings()
        name = self.get_id()
        logger.debug(f"Saving window state for {self.windowTitle()!r}...")
        settings[f"{name}.geometry"] = self.saveGeometry()
        settings[f"{name}.state"] = self.saveState()
        if recursive:
            for window in self.find_children(MainWindow, recursive=True):
                if window.get_id():
                    window.save_window_state()

    def add_widget_as_dock(
        self,
        name: str,
        title: str,
        vertical: bool = True,
        position: constants.DockPositionStr = "left",
    ) -> widgets.DockWidget:
        dock_widget = widgets.DockWidget(self, name=name, title=title)
        widget = widgets.Widget()
        widget.set_id(f"{name}.widget")
        layout = widgets.BoxLayout(
            "vertical" if vertical else "horizontal", widget, margin=0
        )
        dock_widget.setWidget(widget)
        self.add_dockwidget(dock_widget, position)
        dock_widget.box = layout
        return dock_widget

    def add_dockwidget(
        self,
        dockwidget: QtWidgets.QDockWidget,
        position: constants.DockPositionStr = "left",
    ):
        self.addDockWidget(constants.DOCK_POSITION[position], dockwidget)

    def remove_dockwidgets(self, dockwidgets: Sequence[QtWidgets.QDockWidget]):
        for i in dockwidgets:
            self.removeDockWidget(i)

    def show_blocking(self):
        self.set_modality("application")
        self.show()

    def get_docks(self) -> list[QtWidgets.QDockWidget]:
        return self.find_children(QtWidgets.QDockWidget, recursive=False)

    def get_toolbars(self) -> list[QtWidgets.QToolBar]:
        return self.find_children(QtWidgets.QToolBar, recursive=False)

__getitem__(index: str) -> QtWidgets.QWidget

Source code in prettyqt\widgets\mainwindow.py

def __getitem__(self, index: str) -> QtWidgets.QWidget:
    result = self.find_child(QtWidgets.QWidget, index)
    if result is None:
        raise KeyError("Widget not found")
    return result

__init__(*args, **kwargs)

Source code in prettyqt\widgets\mainwindow.py

def __init__(self, *args, **kwargs):
    super().__init__(*args, **kwargs)
    self.setMenuBar(widgets.MenuBar())
    self.setDockOptions(
        self.DockOption.AllowTabbedDocks  # type: ignore
        | self.DockOption.AllowNestedDocks
        | self.DockOption.GroupedDragging
        | self.DockOption.AnimatedDocks
    )

add_dockwidget(dockwidget: QtWidgets.QDockWidget, position: constants.DockPositionStr = 'left')

Source code in prettyqt\widgets\mainwindow.py

def add_dockwidget(
    self,
    dockwidget: QtWidgets.QDockWidget,
    position: constants.DockPositionStr = "left",
):
    self.addDockWidget(constants.DOCK_POSITION[position], dockwidget)

add_toolbar(toolbar: QtWidgets.QToolBar, position: constants.ToolbarAreaStr = 'top')

Adds a toolbar to the mainmenu at specified area.

Parameters:

Name	Type	Description	Default
toolbar	QtWidgets.QToolBar	toolbar to use	required
position	constants.ToolbarAreaStr	position of the toolbar	'top'

Raises:

Type	Description
InvalidParamError	position does not exist

Source code in prettyqt\widgets\mainwindow.py

def add_toolbar(
    self, toolbar: QtWidgets.QToolBar, position: constants.ToolbarAreaStr = "top"
):
    """Adds a toolbar to the mainmenu at specified area.

    Args:
        toolbar: toolbar to use
        position: position of the toolbar

    Raises:
        InvalidParamError: position does not exist
    """
    if position not in constants.TOOLBAR_AREA:
        raise InvalidParamError(position, constants.TOOLBAR_AREA)
    self.addToolBar(constants.TOOLBAR_AREA[position], toolbar)

add_toolbar_break(position: constants.ToolbarAreaStr = 'top')

Adds a toolbar break to the given area behind the last item.

Parameters:

Name	Type	Description	Default
position	constants.ToolbarAreaStr	position of the toolbar	'top'

Raises:

Type	Description
InvalidParamError	position does not exist

Source code in prettyqt\widgets\mainwindow.py

def add_toolbar_break(self, position: constants.ToolbarAreaStr = "top"):
    """Adds a toolbar break to the given area behind the last item.

    Args:
        position: position of the toolbar

    Raises:
        InvalidParamError: position does not exist
    """
    if position not in constants.TOOLBAR_AREA:
        raise InvalidParamError(position, constants.TOOLBAR_AREA)
    self.addToolBarBreak(constants.TOOLBAR_AREA[position])

add_widget_as_dock(name: str, title: str, vertical: bool = True, position: constants.DockPositionStr = 'left') -> widgets.DockWidget

Source code in prettyqt\widgets\mainwindow.py

def add_widget_as_dock(
    self,
    name: str,
    title: str,
    vertical: bool = True,
    position: constants.DockPositionStr = "left",
) -> widgets.DockWidget:
    dock_widget = widgets.DockWidget(self, name=name, title=title)
    widget = widgets.Widget()
    widget.set_id(f"{name}.widget")
    layout = widgets.BoxLayout(
        "vertical" if vertical else "horizontal", widget, margin=0
    )
    dock_widget.setWidget(widget)
    self.add_dockwidget(dock_widget, position)
    dock_widget.box = layout
    return dock_widget

createPopupMenu() -> widgets.Menu

Source code in prettyqt\widgets\mainwindow.py

def createPopupMenu(self) -> widgets.Menu:
    # qactions = self.createPopupMenu()
    menu = widgets.Menu(parent=self)
    for i, item in enumerate(self.get_docks()):
        action = widgets.Action(text=item.windowTitle(), parent=self)
        action.set_checkable(True)
        action.set_checked(item.isVisible())
        action.set_shortcut(f"Ctrl+Shift+{i}")
        action.set_shortcut_context("application")
        action.toggled.connect(item.setVisible)
        menu.add(action)
    menu.add_separator()
    for tb in self.get_toolbars():
        action = widgets.Action(text=tb.windowTitle(), parent=self)
        action.set_checkable(True)
        action.toggled.connect(tb.setVisible)
        action.set_checked(tb.isVisible())
        menu.add(action)
    return menu

get_docks() -> list[QtWidgets.QDockWidget]

Source code in prettyqt\widgets\mainwindow.py

def get_docks(self) -> list[QtWidgets.QDockWidget]:
    return self.find_children(QtWidgets.QDockWidget, recursive=False)

get_toolbars() -> list[QtWidgets.QToolBar]

Source code in prettyqt\widgets\mainwindow.py

def get_toolbars(self) -> list[QtWidgets.QToolBar]:
    return self.find_children(QtWidgets.QToolBar, recursive=False)

load_window_state(recursive: bool = False) -> bool

Source code in prettyqt\widgets\mainwindow.py

def load_window_state(self, recursive: bool = False) -> bool:
    settings = core.Settings()
    name = self.get_id()
    geom = settings.get(f"{name}.geometry")
    state = settings.get(f"{name}.state")
    restored = False
    if geom is not None and state is not None:
        try:
            logger.debug(f"Loading window state for {self.windowTitle()!r}...")
            self.restoreGeometry(geom)
            if isinstance(state, str):
                state = state.encode()
            self.restoreState(state)
            restored = True
        except TypeError:
            logger.error("Wrong type for window state. Probably Qt binding switch?")
    if recursive:
        for window in self.find_children(MainWindow, recursive=True):
            if window.get_id():
                window.load_window_state()
    return restored

remove_dockwidgets(dockwidgets: Sequence[QtWidgets.QDockWidget])

Source code in prettyqt\widgets\mainwindow.py

def remove_dockwidgets(self, dockwidgets: Sequence[QtWidgets.QDockWidget]):
    for i in dockwidgets:
        self.removeDockWidget(i)

save_window_state(recursive: bool = False)

Save current window state as QSetting.

Parameters:

Name	Type	Description	Default
recursive	bool	Description	False

Source code in prettyqt\widgets\mainwindow.py

def save_window_state(self, recursive: bool = False):
    """Save current window state as QSetting.

    Args:
        recursive (bool, optional): Description
    """
    settings = core.Settings()
    name = self.get_id()
    logger.debug(f"Saving window state for {self.windowTitle()!r}...")
    settings[f"{name}.geometry"] = self.saveGeometry()
    settings[f"{name}.state"] = self.saveState()
    if recursive:
        for window in self.find_children(MainWindow, recursive=True):
            if window.get_id():
                window.save_window_state()

set_widget(widget: QtWidgets.QWidget | None)

Source code in prettyqt\widgets\mainwindow.py

def set_widget(self, widget: QtWidgets.QWidget | None):
    if widget is None:
        self.takeCentralWidget()
    else:
        self.setCentralWidget(widget)

show_blocking()

Source code in prettyqt\widgets\mainwindow.py

def show_blocking(self):
    self.set_modality("application")
    self.show()

MdiArea

Bases: widgets.AbstractScrollAreaMixin, QtWidgets.QMdiArea

Source code in prettyqt\widgets\mdiarea.py

class MdiArea(widgets.AbstractScrollAreaMixin, QtWidgets.QMdiArea):
    def __add__(self, other: QtWidgets.QWidget):
        self.add(other)
        return self

    def set_view_mode(self, mode: ViewModeStr):
        """Set view mode for the MDI area.

        Args:
            mode: view mode to use

        Raises:
            InvalidParamError: view mode does not exist
        """
        if mode not in VIEW_MODE:
            raise InvalidParamError(mode, VIEW_MODE)
        self.setViewMode(VIEW_MODE[mode])

    def get_view_mode(self) -> ViewModeStr:
        """Return current view mode.

        Returns:
            view mode
        """
        return VIEW_MODE.inverse[self.viewMode()]

    def set_window_order(self, mode: WindowOrderStr):
        """Set the window order behaviour for the MDI area.

        Args:
            mode: window order behaviour to use

        Raises:
            InvalidParamError: window order mode not existing.
        """
        if mode not in WINDOW_ORDER:
            raise InvalidParamError(mode, WINDOW_ORDER)
        self.setActivationOrder(WINDOW_ORDER[mode])

    def get_window_order(self) -> WindowOrderStr:
        """Return current window order.

        Returns:
            view mode
        """
        return WINDOW_ORDER.inverse[self.activationOrder()]

    def set_tab_position(self, position: TabPositionStr):
        """Set tab position for the MDI area.

        Args:
            position: tabs position to use

        Raises:
            InvalidParamError: tab position does not exist
        """
        if position not in TAB_POSITION:
            raise InvalidParamError(position, TAB_POSITION)
        self.setTabPosition(TAB_POSITION[position])

    def get_tab_position(self) -> TabPositionStr:
        """Return current tab position.

        Returns:
            tab position
        """
        return TAB_POSITION.inverse[self.tabPosition()]

    def set_background(
        self,
        brush_or_color: datatypes.ColorAndBrushType,
        pattern: constants.BrushStyleStr = "solid",
    ):
        if isinstance(brush_or_color, QtGui.QBrush):
            brush = brush_or_color
        else:
            color = colors.get_color(brush_or_color)
            brush = gui.Brush(color, constants.BRUSH_STYLE[pattern])
        self.setBackground(brush)

    def get_background(self) -> gui.Brush:
        return gui.Brush(self.background())

    def add(self, *item: QtWidgets.QWidget):
        for i in item:
            if not isinstance(i, QtWidgets.QMdiSubWindow):
                widget = widgets.MdiSubWindow()
                widget.setWidget(i)
                self.addSubWindow(widget)
            else:
                self.addSubWindow(i)

__add__(other: QtWidgets.QWidget)

Source code in prettyqt\widgets\mdiarea.py

def __add__(self, other: QtWidgets.QWidget):
    self.add(other)
    return self

add(*item: QtWidgets.QWidget)

Source code in prettyqt\widgets\mdiarea.py

def add(self, *item: QtWidgets.QWidget):
    for i in item:
        if not isinstance(i, QtWidgets.QMdiSubWindow):
            widget = widgets.MdiSubWindow()
            widget.setWidget(i)
            self.addSubWindow(widget)
        else:
            self.addSubWindow(i)

get_background() -> gui.Brush

Source code in prettyqt\widgets\mdiarea.py

def get_background(self) -> gui.Brush:
    return gui.Brush(self.background())

get_tab_position() -> TabPositionStr

Return current tab position.

Returns:

Type	Description
TabPositionStr	tab position

Source code in prettyqt\widgets\mdiarea.py

def get_tab_position(self) -> TabPositionStr:
    """Return current tab position.

    Returns:
        tab position
    """
    return TAB_POSITION.inverse[self.tabPosition()]

get_view_mode() -> ViewModeStr

Return current view mode.

Returns:

Type	Description
ViewModeStr	view mode

Source code in prettyqt\widgets\mdiarea.py

def get_view_mode(self) -> ViewModeStr:
    """Return current view mode.

    Returns:
        view mode
    """
    return VIEW_MODE.inverse[self.viewMode()]

get_window_order() -> WindowOrderStr

Return current window order.

Returns:

Type	Description
WindowOrderStr	view mode

Source code in prettyqt\widgets\mdiarea.py

def get_window_order(self) -> WindowOrderStr:
    """Return current window order.

    Returns:
        view mode
    """
    return WINDOW_ORDER.inverse[self.activationOrder()]

set_background(brush_or_color: datatypes.ColorAndBrushType, pattern: constants.BrushStyleStr = 'solid')

Source code in prettyqt\widgets\mdiarea.py

def set_background(
    self,
    brush_or_color: datatypes.ColorAndBrushType,
    pattern: constants.BrushStyleStr = "solid",
):
    if isinstance(brush_or_color, QtGui.QBrush):
        brush = brush_or_color
    else:
        color = colors.get_color(brush_or_color)
        brush = gui.Brush(color, constants.BRUSH_STYLE[pattern])
    self.setBackground(brush)

set_tab_position(position: TabPositionStr)

Set tab position for the MDI area.

Parameters:

Name	Type	Description	Default
position	TabPositionStr	tabs position to use	required

Raises:

Type	Description
InvalidParamError	tab position does not exist

Source code in prettyqt\widgets\mdiarea.py

def set_tab_position(self, position: TabPositionStr):
    """Set tab position for the MDI area.

    Args:
        position: tabs position to use

    Raises:
        InvalidParamError: tab position does not exist
    """
    if position not in TAB_POSITION:
        raise InvalidParamError(position, TAB_POSITION)
    self.setTabPosition(TAB_POSITION[position])

set_view_mode(mode: ViewModeStr)

Set view mode for the MDI area.

Parameters:

Name	Type	Description	Default
mode	ViewModeStr	view mode to use	required

Raises:

Type	Description
InvalidParamError	view mode does not exist

Source code in prettyqt\widgets\mdiarea.py

def set_view_mode(self, mode: ViewModeStr):
    """Set view mode for the MDI area.

    Args:
        mode: view mode to use

    Raises:
        InvalidParamError: view mode does not exist
    """
    if mode not in VIEW_MODE:
        raise InvalidParamError(mode, VIEW_MODE)
    self.setViewMode(VIEW_MODE[mode])

set_window_order(mode: WindowOrderStr)

Set the window order behaviour for the MDI area.

Parameters:

Name	Type	Description	Default
mode	WindowOrderStr	window order behaviour to use	required

Raises:

Type	Description
InvalidParamError	window order mode not existing.

Source code in prettyqt\widgets\mdiarea.py

def set_window_order(self, mode: WindowOrderStr):
    """Set the window order behaviour for the MDI area.

    Args:
        mode: window order behaviour to use

    Raises:
        InvalidParamError: window order mode not existing.
    """
    if mode not in WINDOW_ORDER:
        raise InvalidParamError(mode, WINDOW_ORDER)
    self.setActivationOrder(WINDOW_ORDER[mode])

MdiSubWindow

Bases: widgets.WidgetMixin, QtWidgets.QMdiSubWindow

Source code in prettyqt\widgets\mdisubwindow.py

class MdiSubWindow(widgets.WidgetMixin, QtWidgets.QMdiSubWindow):
    def serialize_fields(self):
        return dict(
            keyboard_single_step=self.keyboardSingleStep(),
            keyboard_page_step=self.keyboardPageStep(),
        )

serialize_fields()

Source code in prettyqt\widgets\mdisubwindow.py

def serialize_fields(self):
    return dict(
        keyboard_single_step=self.keyboardSingleStep(),
        keyboard_page_step=self.keyboardPageStep(),
    )

Menu

Bases: MenuMixin, QtWidgets.QMenu

Source code in prettyqt\widgets\menu.py

class Menu(MenuMixin, QtWidgets.QMenu):
    pass

MenuBar

Bases: widgets.WidgetMixin, QtWidgets.QMenuBar

Source code in prettyqt\widgets\menubar.py

class MenuBar(widgets.WidgetMixin, QtWidgets.QMenuBar):
    def __add__(self, other: QtWidgets.QAction | QtWidgets.QMenu):
        self.add(other)
        return self

    def serialize_fields(self):
        return dict(
            default_up=self.isDefaultUp(),
            native_menu_bar=self.isNativeMenuBar(),
        )

    def add_action(self, action: QtWidgets.QAction | str) -> QtWidgets.QAction:
        if isinstance(action, str):
            action = widgets.Action(parent=self, text=action)
        self.addAction(action)
        return action

    @overload
    def add_menu(self, menu_or_str: str) -> widgets.Menu:
        ...

    @overload
    def add_menu(self, menu_or_str: QtWidgets.QMenu) -> widgets.Action:
        ...

    def add_menu(self, menu_or_str):
        action = widgets.Action(parent=self)
        if isinstance(menu_or_str, str):
            menu = widgets.Menu(menu_or_str)
            action.set_text(menu_or_str)
            action.set_menu(menu)
            self.addAction(action)
            return menu
        else:
            action.set_menu(menu_or_str)
            action.set_text(menu_or_str.title())
            self.addAction(action)
            return action

    def add_separator(self):
        self.addSeparator()

    def add(self, *items: QtWidgets.QMenu | QtWidgets.QAction):
        for i in items:
            if isinstance(i, QtWidgets.QMenu):
                action = widgets.Action(parent=self)
                action.set_text(i.title())
                action.set_menu(i)
                self.addAction(action)
            else:
                self.addAction(i)

    def set_corner_widget(
        self,
        widget: QtWidgets.QWidget,
        corner: Literal["top_right", "top_left"] = "top_right",
    ):
        match corner:
            case "top_left":
                self.setCornerWidget(widget, QtCore.Qt.Corner.TopLeftCorner)
            case "top_right":
                self.setCornerWidget(widget, QtCore.Qt.Corner.TopRightCorner)
            case _:
                raise ValueError(corner)

    def get_corner_widget(
        self,
        corner: Literal["top_right", "top_left"] = "top_right",
    ) -> QtWidgets.QWidget:
        match corner:
            case "top_left":
                return self.cornerWidget(QtCore.Qt.Corner.TopLeftCorner)
            case "top_right":
                return self.cornerWidget(QtCore.Qt.Corner.TopRightCorner)
            case _:
                raise ValueError(corner)

__add__(other: QtWidgets.QAction | QtWidgets.QMenu)

Source code in prettyqt\widgets\menubar.py

def __add__(self, other: QtWidgets.QAction | QtWidgets.QMenu):
    self.add(other)
    return self

add(*items: QtWidgets.QMenu | QtWidgets.QAction)

Source code in prettyqt\widgets\menubar.py

def add(self, *items: QtWidgets.QMenu | QtWidgets.QAction):
    for i in items:
        if isinstance(i, QtWidgets.QMenu):
            action = widgets.Action(parent=self)
            action.set_text(i.title())
            action.set_menu(i)
            self.addAction(action)
        else:
            self.addAction(i)

add_action(action: QtWidgets.QAction | str) -> QtWidgets.QAction

Source code in prettyqt\widgets\menubar.py

def add_action(self, action: QtWidgets.QAction | str) -> QtWidgets.QAction:
    if isinstance(action, str):
        action = widgets.Action(parent=self, text=action)
    self.addAction(action)
    return action

add_menu(menu_or_str)

Source code in prettyqt\widgets\menubar.py

def add_menu(self, menu_or_str):
    action = widgets.Action(parent=self)
    if isinstance(menu_or_str, str):
        menu = widgets.Menu(menu_or_str)
        action.set_text(menu_or_str)
        action.set_menu(menu)
        self.addAction(action)
        return menu
    else:
        action.set_menu(menu_or_str)
        action.set_text(menu_or_str.title())
        self.addAction(action)
        return action

add_separator()

Source code in prettyqt\widgets\menubar.py

def add_separator(self):
    self.addSeparator()

get_corner_widget(corner: Literal['top_right', 'top_left'] = 'top_right') -> QtWidgets.QWidget

Source code in prettyqt\widgets\menubar.py

def get_corner_widget(
    self,
    corner: Literal["top_right", "top_left"] = "top_right",
) -> QtWidgets.QWidget:
    match corner:
        case "top_left":
            return self.cornerWidget(QtCore.Qt.Corner.TopLeftCorner)
        case "top_right":
            return self.cornerWidget(QtCore.Qt.Corner.TopRightCorner)
        case _:
            raise ValueError(corner)

serialize_fields()

Source code in prettyqt\widgets\menubar.py

def serialize_fields(self):
    return dict(
        default_up=self.isDefaultUp(),
        native_menu_bar=self.isNativeMenuBar(),
    )

set_corner_widget(widget: QtWidgets.QWidget, corner: Literal['top_right', 'top_left'] = 'top_right')

Source code in prettyqt\widgets\menubar.py

def set_corner_widget(
    self,
    widget: QtWidgets.QWidget,
    corner: Literal["top_right", "top_left"] = "top_right",
):
    match corner:
        case "top_left":
            self.setCornerWidget(widget, QtCore.Qt.Corner.TopLeftCorner)
        case "top_right":
            self.setCornerWidget(widget, QtCore.Qt.Corner.TopRightCorner)
        case _:
            raise ValueError(corner)

MessageBox

Bases: widgets.DialogMixin, QtWidgets.QMessageBox

Source code in prettyqt\widgets\messagebox.py

class MessageBox(widgets.DialogMixin, QtWidgets.QMessageBox):
    def __init__(
        self,
        icon: datatypes.IconType | IconStr = None,
        title: str = "",
        text: str = "",
        informative_text: str = "",
        details: str = "",
        buttons: list[ButtonStr] | None = None,
        parent: QtWidgets.QWidget | None = None,
    ):
        super().__init__(parent)
        self.set_icon(icon)
        self.setText(text)
        self.setInformativeText(informative_text)
        self.setWindowTitle(title)
        self.setWindowFlags(
            QtCore.Qt.WindowType.Dialog  # type: ignore
            | QtCore.Qt.WindowType.WindowTitleHint
            | QtCore.Qt.WindowType.CustomizeWindowHint
        )
        self.setDetailedText(details)
        if isinstance(buttons, list):
            for b in buttons:
                self.add_button(b)

    def serialize_fields(self):
        return dict(
            icon=self.get_icon(),
            detailed_text=self.detailedText(),
            icon_pixmap=self.get_icon_pixmap(),
            informative_text=self.informativeText(),
            text=self.text(),
            text_format=self.get_text_format(),
        )

    @classmethod
    def message(
        cls,
        text: str,
        title: str = "",
        icon: datatypes.IconType = None,
        detail_text: str | None = None,
    ) -> str:
        m = cls("none", title, text)
        m.set_icon(icon)
        if detail_text is not None:
            m.setDetailedText(detail_text)
        return m.show_blocking()

    @classmethod
    def show_exception(cls, exception: Exception):
        exctype, value = sys.exc_info()[:2]
        tb = traceback.format_exc()
        dlg = cls(text=str(value), title=str(exctype), icon="critical", details=tb)
        dlg.show_blocking()

    def set_icon(self, icon: datatypes.IconType | IconStr):
        if icon in ICONS:
            self.setIcon(ICONS[icon])
        else:
            ico = iconprovider.get_icon(icon)
            self.setIconPixmap(ico.get_pixmap(size=64))

    def show_blocking(self) -> ButtonStr:
        return BUTTONS.inverse[self.main_loop()]

    def get_icon_pixmap(self) -> gui.Pixmap | None:
        pix = self.iconPixmap()
        return None if pix.isNull() else gui.Pixmap(pix)

    def get_standard_buttons(self) -> list[ButtonStr]:
        return BUTTONS.get_list(self.standardButtons())

    def add_button(self, button: ButtonStr) -> QtWidgets.QPushButton:
        """Add a default button.

        Args:
            button: button to add

        Returns:
            created button

        Raises:
            InvalidParamError: Button type not available
        """
        if button not in BUTTONS:
            raise InvalidParamError(button, BUTTONS)
        return self.addButton(BUTTONS[button])

    # @classmethod
    # def show_exception(cls, exception):
    #     header = str(exception[0])
    #     error_text = str(exception[1])
    #     widgets.MessageBox.message(error_text, header, "mdi.exclamation")

    def set_text_format(self, text_format: TextFormatStr):
        """Set the text format.

        Args:
            text_format: text format to use

        Raises:
            InvalidParamError: text format does not exist
        """
        if text_format not in TEXT_FORMAT:
            raise InvalidParamError(text_format, TEXT_FORMAT)
        self.setTextFormat(TEXT_FORMAT[text_format])

    def get_text_format(self) -> TextFormatStr:
        """Return current text format.

        Returns:
            text format
        """
        return TEXT_FORMAT.inverse[self.textFormat()]

    def set_escape_button(self, button: ButtonStr | QtWidgets.QAbstractButton):
        if isinstance(button, QtWidgets.QAbstractButton):
            self.setEscapeButton(button)
        else:
            self.setEscapeButton(BUTTONS[button])

    def set_default_button(self, button: ButtonStr | QtWidgets.QPushButton):
        if isinstance(button, QtWidgets.QPushButton):
            self.setDefaultButton(button)
        else:
            self.setDefaultButton(BUTTONS[button])

__init__(icon: datatypes.IconType | IconStr = None, title: str = '', text: str = '', informative_text: str = '', details: str = '', buttons: list[ButtonStr] | None = None, parent: QtWidgets.QWidget | None = None)

Source code in prettyqt\widgets\messagebox.py

def __init__(
    self,
    icon: datatypes.IconType | IconStr = None,
    title: str = "",
    text: str = "",
    informative_text: str = "",
    details: str = "",
    buttons: list[ButtonStr] | None = None,
    parent: QtWidgets.QWidget | None = None,
):
    super().__init__(parent)
    self.set_icon(icon)
    self.setText(text)
    self.setInformativeText(informative_text)
    self.setWindowTitle(title)
    self.setWindowFlags(
        QtCore.Qt.WindowType.Dialog  # type: ignore
        | QtCore.Qt.WindowType.WindowTitleHint
        | QtCore.Qt.WindowType.CustomizeWindowHint
    )
    self.setDetailedText(details)
    if isinstance(buttons, list):
        for b in buttons:
            self.add_button(b)

add_button(button: ButtonStr) -> QtWidgets.QPushButton

Add a default button.

Parameters:

Name	Type	Description	Default
button	ButtonStr	button to add	required

Returns:

Type	Description
QtWidgets.QPushButton	created button

Raises:

Type	Description
InvalidParamError	Button type not available

Source code in prettyqt\widgets\messagebox.py

def add_button(self, button: ButtonStr) -> QtWidgets.QPushButton:
    """Add a default button.

    Args:
        button: button to add

    Returns:
        created button

    Raises:
        InvalidParamError: Button type not available
    """
    if button not in BUTTONS:
        raise InvalidParamError(button, BUTTONS)
    return self.addButton(BUTTONS[button])

get_icon_pixmap() -> gui.Pixmap | None

Source code in prettyqt\widgets\messagebox.py

def get_icon_pixmap(self) -> gui.Pixmap | None:
    pix = self.iconPixmap()
    return None if pix.isNull() else gui.Pixmap(pix)

get_standard_buttons() -> list[ButtonStr]

Source code in prettyqt\widgets\messagebox.py

def get_standard_buttons(self) -> list[ButtonStr]:
    return BUTTONS.get_list(self.standardButtons())

get_text_format() -> TextFormatStr

Return current text format.

Returns:

Type	Description
TextFormatStr	text format

Source code in prettyqt\widgets\messagebox.py

def get_text_format(self) -> TextFormatStr:
    """Return current text format.

    Returns:
        text format
    """
    return TEXT_FORMAT.inverse[self.textFormat()]

message(text: str, title: str = '', icon: datatypes.IconType = None, detail_text: str | None = None) -> str classmethod

Source code in prettyqt\widgets\messagebox.py

@classmethod
def message(
    cls,
    text: str,
    title: str = "",
    icon: datatypes.IconType = None,
    detail_text: str | None = None,
) -> str:
    m = cls("none", title, text)
    m.set_icon(icon)
    if detail_text is not None:
        m.setDetailedText(detail_text)
    return m.show_blocking()

serialize_fields()

Source code in prettyqt\widgets\messagebox.py

def serialize_fields(self):
    return dict(
        icon=self.get_icon(),
        detailed_text=self.detailedText(),
        icon_pixmap=self.get_icon_pixmap(),
        informative_text=self.informativeText(),
        text=self.text(),
        text_format=self.get_text_format(),
    )

set_default_button(button: ButtonStr | QtWidgets.QPushButton)

Source code in prettyqt\widgets\messagebox.py

def set_default_button(self, button: ButtonStr | QtWidgets.QPushButton):
    if isinstance(button, QtWidgets.QPushButton):
        self.setDefaultButton(button)
    else:
        self.setDefaultButton(BUTTONS[button])

set_escape_button(button: ButtonStr | QtWidgets.QAbstractButton)

Source code in prettyqt\widgets\messagebox.py

def set_escape_button(self, button: ButtonStr | QtWidgets.QAbstractButton):
    if isinstance(button, QtWidgets.QAbstractButton):
        self.setEscapeButton(button)
    else:
        self.setEscapeButton(BUTTONS[button])

set_icon(icon: datatypes.IconType | IconStr)

Source code in prettyqt\widgets\messagebox.py

def set_icon(self, icon: datatypes.IconType | IconStr):
    if icon in ICONS:
        self.setIcon(ICONS[icon])
    else:
        ico = iconprovider.get_icon(icon)
        self.setIconPixmap(ico.get_pixmap(size=64))

set_text_format(text_format: TextFormatStr)

Set the text format.

Parameters:

Name	Type	Description	Default
text_format	TextFormatStr	text format to use	required

Raises:

Type	Description
InvalidParamError	text format does not exist

Source code in prettyqt\widgets\messagebox.py

def set_text_format(self, text_format: TextFormatStr):
    """Set the text format.

    Args:
        text_format: text format to use

    Raises:
        InvalidParamError: text format does not exist
    """
    if text_format not in TEXT_FORMAT:
        raise InvalidParamError(text_format, TEXT_FORMAT)
    self.setTextFormat(TEXT_FORMAT[text_format])

show_blocking() -> ButtonStr

Source code in prettyqt\widgets\messagebox.py

def show_blocking(self) -> ButtonStr:
    return BUTTONS.inverse[self.main_loop()]

show_exception(exception: Exception) classmethod

Source code in prettyqt\widgets\messagebox.py

@classmethod
def show_exception(cls, exception: Exception):
    exctype, value = sys.exc_info()[:2]
    tb = traceback.format_exc()
    dlg = cls(text=str(value), title=str(exctype), icon="critical", details=tb)
    dlg.show_blocking()

PanGesture

Bases: widgets.GestureMixin, QtWidgets.QPanGesture

Source code in prettyqt\widgets\pangesture.py

class PanGesture(widgets.GestureMixin, QtWidgets.QPanGesture):
    def get_delta(self) -> core.PointF:
        return core.PointF(self.delta())

    def get_last_offset(self) -> core.PointF:
        return core.PointF(self.lastOffset())

    def get_offset(self) -> core.PointF:
        return core.PointF(self.offset())

get_delta() -> core.PointF

Source code in prettyqt\widgets\pangesture.py

def get_delta(self) -> core.PointF:
    return core.PointF(self.delta())

get_last_offset() -> core.PointF

Source code in prettyqt\widgets\pangesture.py

def get_last_offset(self) -> core.PointF:
    return core.PointF(self.lastOffset())

get_offset() -> core.PointF

Source code in prettyqt\widgets\pangesture.py

def get_offset(self) -> core.PointF:
    return core.PointF(self.offset())

PinchGesture

Bases: widgets.GestureMixin, QtWidgets.QPinchGesture

Source code in prettyqt\widgets\pinchgesture.py

class PinchGesture(widgets.GestureMixin, QtWidgets.QPinchGesture):
    def get_start_center_point(self) -> core.PointF:
        return core.PointF(self.startCenterPoint())

    def get_center_point(self) -> core.PointF:
        return core.PointF(self.centerPoint())

    def get_last_center_point(self) -> core.PointF:
        return core.PointF(self.lastCenterPoint())

    def get_change_flags(self) -> list[ChangeFlagStr]:
        return CHANGE_FLAGS.get_list(self.changeFlags())

    def set_change_flags(self, **kwargs):
        val = QtWidgets.QPinchGesture.ChangeFlag(0)
        for k, v in kwargs.items():
            if v is True:
                val |= CHANGE_FLAGS[k]
        flag = QtWidgets.QPinchGesture.ChangeFlag(val)  # type: ignore
        self.setChangeFlags(flag)  # type: ignore

    def get_total_change_flags(self) -> list[ChangeFlagStr]:
        return CHANGE_FLAGS.get_list(self.totalChangeFlags())

    def set_total_change_flags(self, **kwargs):
        val = QtWidgets.QPinchGesture.ChangeFlag(0)
        for k, v in kwargs.items():
            if v is True:
                val |= CHANGE_FLAGS[k]
        flag = QtWidgets.QPinchGesture.ChangeFlag(val)  # type: ignore
        self.setTotalChangeFlags(flag)  # type: ignore

get_center_point() -> core.PointF

Source code in prettyqt\widgets\pinchgesture.py

def get_center_point(self) -> core.PointF:
    return core.PointF(self.centerPoint())

get_change_flags() -> list[ChangeFlagStr]

Source code in prettyqt\widgets\pinchgesture.py

def get_change_flags(self) -> list[ChangeFlagStr]:
    return CHANGE_FLAGS.get_list(self.changeFlags())

get_last_center_point() -> core.PointF

Source code in prettyqt\widgets\pinchgesture.py

def get_last_center_point(self) -> core.PointF:
    return core.PointF(self.lastCenterPoint())

get_start_center_point() -> core.PointF

Source code in prettyqt\widgets\pinchgesture.py

def get_start_center_point(self) -> core.PointF:
    return core.PointF(self.startCenterPoint())

get_total_change_flags() -> list[ChangeFlagStr]

Source code in prettyqt\widgets\pinchgesture.py

def get_total_change_flags(self) -> list[ChangeFlagStr]:
    return CHANGE_FLAGS.get_list(self.totalChangeFlags())

set_change_flags(**kwargs)

Source code in prettyqt\widgets\pinchgesture.py

def set_change_flags(self, **kwargs):
    val = QtWidgets.QPinchGesture.ChangeFlag(0)
    for k, v in kwargs.items():
        if v is True:
            val |= CHANGE_FLAGS[k]
    flag = QtWidgets.QPinchGesture.ChangeFlag(val)  # type: ignore
    self.setChangeFlags(flag)  # type: ignore

set_total_change_flags(**kwargs)

Source code in prettyqt\widgets\pinchgesture.py

def set_total_change_flags(self, **kwargs):
    val = QtWidgets.QPinchGesture.ChangeFlag(0)
    for k, v in kwargs.items():
        if v is True:
            val |= CHANGE_FLAGS[k]
    flag = QtWidgets.QPinchGesture.ChangeFlag(val)  # type: ignore
    self.setTotalChangeFlags(flag)  # type: ignore

PlainTextDocumentLayout

Bases: gui.AbstractTextDocumentLayoutMixin, QtWidgets.QPlainTextDocumentLayout

Source code in prettyqt\widgets\plaintextdocumentlayout.py

class PlainTextDocumentLayout(
    gui.AbstractTextDocumentLayoutMixin, QtWidgets.QPlainTextDocumentLayout
):
    def serialize_fields(self):
        return dict(cursor_width=self.cursorWidth())

serialize_fields()

Source code in prettyqt\widgets\plaintextdocumentlayout.py

def serialize_fields(self):
    return dict(cursor_width=self.cursorWidth())

PlainTextEdit

Bases: PlainTextEditMixin, QtWidgets.QPlainTextEdit

Source code in prettyqt\widgets\plaintextedit.py

class PlainTextEdit(PlainTextEditMixin, QtWidgets.QPlainTextEdit):
    pass

PlainTextEditMixin

Bases: widgets.AbstractScrollAreaMixin

Source code in prettyqt\widgets\plaintextedit.py

class PlainTextEditMixin(widgets.AbstractScrollAreaMixin):
    value_changed = core.Signal()

    def __init__(
        self,
        text: str = "",
        parent: QtWidgets.QWidget | None = None,
        read_only: bool = False,
    ):
        super().__init__(parent)
        self._allow_wheel_zoom = False
        self.validator: QtGui.QValidator | None = None
        self.textChanged.connect(self._on_value_change)
        self.set_read_only(read_only)
        doc = gui.TextDocument(self)
        layout = widgets.PlainTextDocumentLayout(doc)
        doc.setDocumentLayout(layout)
        self.setDocument(doc)
        self.set_text(text)

    def __add__(self, other: str):
        self.append_text(other)
        return self

    def wheelEvent(self, event):
        """Handle wheel event for zooming."""
        if not self._allow_wheel_zoom:
            return None
        if event.modifiers() & constants.CTRL_MOD:
            self.zoomIn() if event.angleDelta().y() > 0 else self.zoomOut()
        else:
            super().wheelEvent(event)

    def allow_wheel_zoom(self, do_zoom: bool = True):
        self._allow_wheel_zoom = do_zoom

    def goto_line(self, line_no: int):
        doc = self.document()
        lines = doc.blockCount()
        assert 1 <= line_no <= lines
        pos = doc.findBlockByLineNumber(line_no - 1).position()
        with self.current_cursor() as text_cursor:
            text_cursor.setPosition(pos)

    def get_selected_text(self) -> str:
        if self.textCursor().hasSelection():
            return self.textCursor().selectedText()
        else:
            return ""

    def get_current_line(self) -> int:
        return self.textCursor().blockNumber()

    def get_selected_rows(self) -> tuple[int, int]:
        start = self.textCursor().selectionStart()
        end = self.textCursor().selectionEnd()
        start_block_id = self.document().findBlock(start).blockNumber()
        end_block_id = self.document().findBlock(end).blockNumber()

        return (start_block_id, end_block_id)

    @contextlib.contextmanager
    def create_cursor(self) -> Iterator[gui.TextCursor]:
        cursor = gui.TextCursor(self.document())
        yield cursor
        self.setTextCursor(cursor)

    @contextlib.contextmanager
    def current_cursor(self) -> Iterator[gui.TextCursor]:
        cursor = gui.TextCursor(self.textCursor())
        yield cursor
        self.setTextCursor(cursor)

    def get_text_cursor(self) -> gui.TextCursor:
        return gui.TextCursor(self.textCursor())

    def move_cursor(
        self,
        operation: gui.textcursor.MoveOperationStr,
        mode: gui.textcursor.MoveModeStr = "move",
    ):
        self.moveCursor(
            gui.textcursor.MOVE_OPERATION[operation], gui.textcursor.MOVE_MODE[mode]
        )

    def append_text(self, text: str, newline: bool = True):
        if newline:
            self.appendPlainText(text)
        else:
            self.move_cursor("end")
            self.insertPlainText(text)
            self.move_cursor("end")

    def set_text(self, text: str):
        self.setPlainText(text)

    def set_syntaxhighlighter(self, syntax: str, style: str | None = None):
        self._hl = syntaxhighlighters.PygmentsHighlighter(self.document(), syntax, style)

    def text(self) -> str:
        return self.toPlainText()

    def select_text(self, start: int, end: int):
        with self.create_cursor() as c:
            c.select_text(start, end)

    def set_read_only(self, value: bool = True):
        """Make the PlainTextEdit read-only.

        Args:
            value: True, for read-only, otherwise False
        """
        self.setReadOnly(value)

    def show_whitespace_and_tabs(self, show: bool):
        """Set show white spaces flag."""
        doc = self.document()
        options = doc.defaultTextOption()
        flag = QtGui.QTextOption.Flag.ShowTabsAndSpaces
        if show:
            options.setFlags(options.flags() | flag)  # type: ignore
        else:
            options.setFlags(options.flags() & ~flag)  # type: ignore
        doc.setDefaultTextOption(options)

    def highlight_current_line(self, color: datatypes.ColorType = None):
        if color is None:
            color = self.get_palette().get_color("highlight")
        else:
            color = colors.get_color(color)
        extra_selections = []

        if not self.isReadOnly():
            selection = widgets.TextEdit.ExtraSelection()
            selection.format.setBackground(color)
            prop = QtGui.QTextFormat.Property.FullWidthSelection
            selection.format.setProperty(prop, True)
            selection.cursor = self.textCursor()
            selection.cursor.clearSelection()
            extra_selections.append(selection)

        self.setExtraSelections(extra_selections)

    @deprecated(reason="This method is deprecated, use set_word_wrap_mode instead.")
    def set_wrap_mode(self, mode: gui.textoption.WordWrapModeStr):
        self.set_word_wrap_mode(mode)

    def set_word_wrap_mode(self, mode: gui.textoption.WordWrapModeStr):
        """Set word wrap mode.

        Args:
            mode: word wrap mode to use

        Raises:
            InvalidParamError: wrap mode does not exist
        """
        if mode not in gui.textoption.WORD_WRAP_MODE:
            raise InvalidParamError(mode, gui.textoption.WORD_WRAP_MODE)
        self.setWordWrapMode(gui.textoption.WORD_WRAP_MODE[mode])

    @deprecated(reason="This method is deprecated, use get_word_wrap_mode instead.")
    def get_wrap_mode(self) -> gui.textoption.WordWrapModeStr:
        return self.get_word_wrap_mode()

    def get_word_wrap_mode(self) -> gui.textoption.WordWrapModeStr:
        """Get the current word wrap mode.

        Returns:
            Word wrap mode
        """
        return gui.textoption.WORD_WRAP_MODE.inverse[self.wordWrapMode()]

    def set_line_wrap_mode(self, mode: LineWrapModeStr):
        """Set line wrap mode.

        Args:
            mode: line wrap mode to use

        Raises:
            InvalidParamError: line wrap mode does not exist
        """
        if mode not in LINE_WRAP_MODE:
            raise InvalidParamError(mode, LINE_WRAP_MODE)
        self.setLineWrapMode(LINE_WRAP_MODE[mode])

    def get_line_wrap_mode(self) -> LineWrapModeStr:
        """Get the current wrap mode.

        Returns:
            Wrap mode
        """
        return LINE_WRAP_MODE.inverse[self.lineWrapMode()]

    def _on_value_change(self):
        self.value_changed.emit()
        if self.validator is not None:
            self._set_validation_color()

    def _set_validation_color(self, state: bool = True):
        color = None if self.is_valid() else "orange"
        self.set_background_color(color)

    def set_validator(self, validator: QtGui.QValidator | None):
        self.validator = validator
        self._set_validation_color()

    def set_regex_validator(self, regex: str, flags=0) -> gui.RegularExpressionValidator:
        validator = gui.RegularExpressionValidator(self)
        validator.set_regex(regex, flags)
        self.set_validator(validator)
        return validator

    def is_valid(self) -> bool:
        if self.validator is None:
            return True
        val = self.validator.validate(self.text(), 0)
        return val[0] == self.validator.State.Acceptable

    def set_value(self, value: str):
        self.setPlainText(value)

    def get_value(self) -> str:
        return self.text()

validator: QtGui.QValidator | None = None instance-attribute

value_changed = core.Signal() class-attribute

__add__(other: str)

Source code in prettyqt\widgets\plaintextedit.py

def __add__(self, other: str):
    self.append_text(other)
    return self

__init__(text: str = '', parent: QtWidgets.QWidget | None = None, read_only: bool = False)

Source code in prettyqt\widgets\plaintextedit.py

def __init__(
    self,
    text: str = "",
    parent: QtWidgets.QWidget | None = None,
    read_only: bool = False,
):
    super().__init__(parent)
    self._allow_wheel_zoom = False
    self.validator: QtGui.QValidator | None = None
    self.textChanged.connect(self._on_value_change)
    self.set_read_only(read_only)
    doc = gui.TextDocument(self)
    layout = widgets.PlainTextDocumentLayout(doc)
    doc.setDocumentLayout(layout)
    self.setDocument(doc)
    self.set_text(text)

allow_wheel_zoom(do_zoom: bool = True)

Source code in prettyqt\widgets\plaintextedit.py

def allow_wheel_zoom(self, do_zoom: bool = True):
    self._allow_wheel_zoom = do_zoom

append_text(text: str, newline: bool = True)

Source code in prettyqt\widgets\plaintextedit.py

def append_text(self, text: str, newline: bool = True):
    if newline:
        self.appendPlainText(text)
    else:
        self.move_cursor("end")
        self.insertPlainText(text)
        self.move_cursor("end")

create_cursor() -> Iterator[gui.TextCursor]

Source code in prettyqt\widgets\plaintextedit.py

@contextlib.contextmanager
def create_cursor(self) -> Iterator[gui.TextCursor]:
    cursor = gui.TextCursor(self.document())
    yield cursor
    self.setTextCursor(cursor)

current_cursor() -> Iterator[gui.TextCursor]

Source code in prettyqt\widgets\plaintextedit.py

@contextlib.contextmanager
def current_cursor(self) -> Iterator[gui.TextCursor]:
    cursor = gui.TextCursor(self.textCursor())
    yield cursor
    self.setTextCursor(cursor)

get_current_line() -> int

Source code in prettyqt\widgets\plaintextedit.py

def get_current_line(self) -> int:
    return self.textCursor().blockNumber()

get_line_wrap_mode() -> LineWrapModeStr

Get the current wrap mode.

Returns:

Type	Description
LineWrapModeStr	Wrap mode

Source code in prettyqt\widgets\plaintextedit.py

def get_line_wrap_mode(self) -> LineWrapModeStr:
    """Get the current wrap mode.

    Returns:
        Wrap mode
    """
    return LINE_WRAP_MODE.inverse[self.lineWrapMode()]

get_selected_rows() -> tuple[int, int]

Source code in prettyqt\widgets\plaintextedit.py

def get_selected_rows(self) -> tuple[int, int]:
    start = self.textCursor().selectionStart()
    end = self.textCursor().selectionEnd()
    start_block_id = self.document().findBlock(start).blockNumber()
    end_block_id = self.document().findBlock(end).blockNumber()

    return (start_block_id, end_block_id)

get_selected_text() -> str

Source code in prettyqt\widgets\plaintextedit.py

def get_selected_text(self) -> str:
    if self.textCursor().hasSelection():
        return self.textCursor().selectedText()
    else:
        return ""

get_text_cursor() -> gui.TextCursor

Source code in prettyqt\widgets\plaintextedit.py

def get_text_cursor(self) -> gui.TextCursor:
    return gui.TextCursor(self.textCursor())

get_value() -> str

Source code in prettyqt\widgets\plaintextedit.py

def get_value(self) -> str:
    return self.text()

get_word_wrap_mode() -> gui.textoption.WordWrapModeStr

Get the current word wrap mode.

Returns:

Type	Description
gui.textoption.WordWrapModeStr	Word wrap mode

Source code in prettyqt\widgets\plaintextedit.py

def get_word_wrap_mode(self) -> gui.textoption.WordWrapModeStr:
    """Get the current word wrap mode.

    Returns:
        Word wrap mode
    """
    return gui.textoption.WORD_WRAP_MODE.inverse[self.wordWrapMode()]

get_wrap_mode() -> gui.textoption.WordWrapModeStr

Source code in prettyqt\widgets\plaintextedit.py

@deprecated(reason="This method is deprecated, use get_word_wrap_mode instead.")
def get_wrap_mode(self) -> gui.textoption.WordWrapModeStr:
    return self.get_word_wrap_mode()

goto_line(line_no: int)

Source code in prettyqt\widgets\plaintextedit.py

def goto_line(self, line_no: int):
    doc = self.document()
    lines = doc.blockCount()
    assert 1 <= line_no <= lines
    pos = doc.findBlockByLineNumber(line_no - 1).position()
    with self.current_cursor() as text_cursor:
        text_cursor.setPosition(pos)

highlight_current_line(color: datatypes.ColorType = None)

Source code in prettyqt\widgets\plaintextedit.py

def highlight_current_line(self, color: datatypes.ColorType = None):
    if color is None:
        color = self.get_palette().get_color("highlight")
    else:
        color = colors.get_color(color)
    extra_selections = []

    if not self.isReadOnly():
        selection = widgets.TextEdit.ExtraSelection()
        selection.format.setBackground(color)
        prop = QtGui.QTextFormat.Property.FullWidthSelection
        selection.format.setProperty(prop, True)
        selection.cursor = self.textCursor()
        selection.cursor.clearSelection()
        extra_selections.append(selection)

    self.setExtraSelections(extra_selections)

is_valid() -> bool

Source code in prettyqt\widgets\plaintextedit.py

def is_valid(self) -> bool:
    if self.validator is None:
        return True
    val = self.validator.validate(self.text(), 0)
    return val[0] == self.validator.State.Acceptable

move_cursor(operation: gui.textcursor.MoveOperationStr, mode: gui.textcursor.MoveModeStr = 'move')

Source code in prettyqt\widgets\plaintextedit.py

def move_cursor(
    self,
    operation: gui.textcursor.MoveOperationStr,
    mode: gui.textcursor.MoveModeStr = "move",
):
    self.moveCursor(
        gui.textcursor.MOVE_OPERATION[operation], gui.textcursor.MOVE_MODE[mode]
    )

select_text(start: int, end: int)

Source code in prettyqt\widgets\plaintextedit.py

def select_text(self, start: int, end: int):
    with self.create_cursor() as c:
        c.select_text(start, end)

set_line_wrap_mode(mode: LineWrapModeStr)

Set line wrap mode.

Parameters:

Name	Type	Description	Default
mode	LineWrapModeStr	line wrap mode to use	required

Raises:

Type	Description
InvalidParamError	line wrap mode does not exist

Source code in prettyqt\widgets\plaintextedit.py

def set_line_wrap_mode(self, mode: LineWrapModeStr):
    """Set line wrap mode.

    Args:
        mode: line wrap mode to use

    Raises:
        InvalidParamError: line wrap mode does not exist
    """
    if mode not in LINE_WRAP_MODE:
        raise InvalidParamError(mode, LINE_WRAP_MODE)
    self.setLineWrapMode(LINE_WRAP_MODE[mode])

set_read_only(value: bool = True)

Make the PlainTextEdit read-only.

Parameters:

Name	Type	Description	Default
value	bool	True, for read-only, otherwise False	True

Source code in prettyqt\widgets\plaintextedit.py

def set_read_only(self, value: bool = True):
    """Make the PlainTextEdit read-only.

    Args:
        value: True, for read-only, otherwise False
    """
    self.setReadOnly(value)

set_regex_validator(regex: str, flags = 0) -> gui.RegularExpressionValidator

Source code in prettyqt\widgets\plaintextedit.py

def set_regex_validator(self, regex: str, flags=0) -> gui.RegularExpressionValidator:
    validator = gui.RegularExpressionValidator(self)
    validator.set_regex(regex, flags)
    self.set_validator(validator)
    return validator

set_syntaxhighlighter(syntax: str, style: str | None = None)

Source code in prettyqt\widgets\plaintextedit.py

def set_syntaxhighlighter(self, syntax: str, style: str | None = None):
    self._hl = syntaxhighlighters.PygmentsHighlighter(self.document(), syntax, style)

set_text(text: str)

Source code in prettyqt\widgets\plaintextedit.py

def set_text(self, text: str):
    self.setPlainText(text)

set_validator(validator: QtGui.QValidator | None)

Source code in prettyqt\widgets\plaintextedit.py

def set_validator(self, validator: QtGui.QValidator | None):
    self.validator = validator
    self._set_validation_color()

set_value(value: str)

Source code in prettyqt\widgets\plaintextedit.py

def set_value(self, value: str):
    self.setPlainText(value)

set_word_wrap_mode(mode: gui.textoption.WordWrapModeStr)

Set word wrap mode.

Parameters:

Name	Type	Description	Default
mode	gui.textoption.WordWrapModeStr	word wrap mode to use	required

Raises:

Type	Description
InvalidParamError	wrap mode does not exist

Source code in prettyqt\widgets\plaintextedit.py

def set_word_wrap_mode(self, mode: gui.textoption.WordWrapModeStr):
    """Set word wrap mode.

    Args:
        mode: word wrap mode to use

    Raises:
        InvalidParamError: wrap mode does not exist
    """
    if mode not in gui.textoption.WORD_WRAP_MODE:
        raise InvalidParamError(mode, gui.textoption.WORD_WRAP_MODE)
    self.setWordWrapMode(gui.textoption.WORD_WRAP_MODE[mode])

set_wrap_mode(mode: gui.textoption.WordWrapModeStr)

Source code in prettyqt\widgets\plaintextedit.py

@deprecated(reason="This method is deprecated, use set_word_wrap_mode instead.")
def set_wrap_mode(self, mode: gui.textoption.WordWrapModeStr):
    self.set_word_wrap_mode(mode)

show_whitespace_and_tabs(show: bool)

Set show white spaces flag.

Source code in prettyqt\widgets\plaintextedit.py

def show_whitespace_and_tabs(self, show: bool):
    """Set show white spaces flag."""
    doc = self.document()
    options = doc.defaultTextOption()
    flag = QtGui.QTextOption.Flag.ShowTabsAndSpaces
    if show:
        options.setFlags(options.flags() | flag)  # type: ignore
    else:
        options.setFlags(options.flags() & ~flag)  # type: ignore
    doc.setDefaultTextOption(options)

text() -> str

Source code in prettyqt\widgets\plaintextedit.py

def text(self) -> str:
    return self.toPlainText()

wheelEvent(event)

Handle wheel event for zooming.

Source code in prettyqt\widgets\plaintextedit.py

def wheelEvent(self, event):
    """Handle wheel event for zooming."""
    if not self._allow_wheel_zoom:
        return None
    if event.modifiers() & constants.CTRL_MOD:
        self.zoomIn() if event.angleDelta().y() > 0 else self.zoomOut()
    else:
        super().wheelEvent(event)

ProgressBar

Bases: widgets.WidgetMixin, QtWidgets.QProgressBar

Progress dialog.

wrapper for QtWidgets.QProgressBar

Source code in prettyqt\widgets\progressbar.py

class ProgressBar(widgets.WidgetMixin, QtWidgets.QProgressBar):
    """Progress dialog.

    wrapper for QtWidgets.QProgressBar
    """

    def __init__(
        self, text_visible: bool = True, parent: QtWidgets.QWidget | None = None
    ):
        super().__init__(parent=parent)
        self.setTextVisible(text_visible)

    def serialize_fields(self):
        return dict(
            alignment=self.get_alignment(),
            format=self.format(),
            # inverted_appearance=self.invertedAppearance(),
            minimum=self.minimum(),
            maximum=self.maximum(),
            orientation=self.get_orientation(),
            text=self.text(),
            # text_direction=self.get_text_direction(),
            text_visible=self.isTextVisible(),
            value=self.value(),
        )

    def set_alignment(self, alignment: constants.AlignmentStr):
        """Set the alignment of the layout.

        Args:
            alignment: alignment for the layout

        Raises:
            InvalidParamError: alignment does not exist
        """
        if alignment not in constants.ALIGNMENTS:
            raise InvalidParamError(alignment, constants.ALIGNMENTS)
        self.setAlignment(constants.ALIGNMENTS[alignment])

    def get_alignment(self) -> constants.AlignmentStr:
        """Return current alignment.

        Returns:
            alignment
        """
        return constants.ALIGNMENTS.inverse[self.alignment()]

    def set_text_direction(self, text_direction: TextDirectionStr):
        """Set the text direction of the layout.

        Args:
            text_direction: text direction for the layout

        Raises:
            InvalidParamError: text direction does not exist
        """
        if text_direction not in TEXT_DIRECTIONS:
            raise InvalidParamError(text_direction, TEXT_DIRECTIONS)
        self.setTextDirection(TEXT_DIRECTIONS[text_direction])

    def get_text_direction(self) -> TextDirectionStr:
        """Return current text direction.

        Returns:
            Text direction
        """
        return TEXT_DIRECTIONS.inverse[self.textDirection()]

    def set_orientation(self, orientation: constants.OrientationStr):
        """Set the orientation of the progress bar.

        Args:
            orientation: orientation for the progress bar

        Raises:
            InvalidParamError: orientation does not exist
        """
        if orientation not in constants.ORIENTATION:
            raise InvalidParamError(orientation, constants.ORIENTATION)
        self.setOrientation(constants.ORIENTATION[orientation])

    def get_orientation(self) -> constants.OrientationStr:
        """Return current orientation.

        Returns:
            orientation
        """
        return constants.ORIENTATION.inverse[self.orientation()]

    def set_range(self, start: int, end: int):
        self.setRange(start, end)

    def set_value(self, value: int):
        self.setValue(value)

    def get_value(self) -> int:
        return self.value()

__init__(text_visible: bool = True, parent: QtWidgets.QWidget | None = None)

Source code in prettyqt\widgets\progressbar.py

def __init__(
    self, text_visible: bool = True, parent: QtWidgets.QWidget | None = None
):
    super().__init__(parent=parent)
    self.setTextVisible(text_visible)

get_alignment() -> constants.AlignmentStr

Return current alignment.

Returns:

Type	Description
constants.AlignmentStr	alignment

Source code in prettyqt\widgets\progressbar.py

def get_alignment(self) -> constants.AlignmentStr:
    """Return current alignment.

    Returns:
        alignment
    """
    return constants.ALIGNMENTS.inverse[self.alignment()]

get_orientation() -> constants.OrientationStr

Return current orientation.

Returns:

Type	Description
constants.OrientationStr	orientation

Source code in prettyqt\widgets\progressbar.py

def get_orientation(self) -> constants.OrientationStr:
    """Return current orientation.

    Returns:
        orientation
    """
    return constants.ORIENTATION.inverse[self.orientation()]

get_text_direction() -> TextDirectionStr

Return current text direction.

Returns:

Type	Description
TextDirectionStr	Text direction

Source code in prettyqt\widgets\progressbar.py

def get_text_direction(self) -> TextDirectionStr:
    """Return current text direction.

    Returns:
        Text direction
    """
    return TEXT_DIRECTIONS.inverse[self.textDirection()]

get_value() -> int

Source code in prettyqt\widgets\progressbar.py

def get_value(self) -> int:
    return self.value()

serialize_fields()

Source code in prettyqt\widgets\progressbar.py

def serialize_fields(self):
    return dict(
        alignment=self.get_alignment(),
        format=self.format(),
        # inverted_appearance=self.invertedAppearance(),
        minimum=self.minimum(),
        maximum=self.maximum(),
        orientation=self.get_orientation(),
        text=self.text(),
        # text_direction=self.get_text_direction(),
        text_visible=self.isTextVisible(),
        value=self.value(),
    )

set_alignment(alignment: constants.AlignmentStr)

Set the alignment of the layout.

Parameters:

Name	Type	Description	Default
alignment	constants.AlignmentStr	alignment for the layout	required

Raises:

Type	Description
InvalidParamError	alignment does not exist

Source code in prettyqt\widgets\progressbar.py

def set_alignment(self, alignment: constants.AlignmentStr):
    """Set the alignment of the layout.

    Args:
        alignment: alignment for the layout

    Raises:
        InvalidParamError: alignment does not exist
    """
    if alignment not in constants.ALIGNMENTS:
        raise InvalidParamError(alignment, constants.ALIGNMENTS)
    self.setAlignment(constants.ALIGNMENTS[alignment])

set_orientation(orientation: constants.OrientationStr)

Set the orientation of the progress bar.

Parameters:

Name	Type	Description	Default
orientation	constants.OrientationStr	orientation for the progress bar	required

Raises:

Type	Description
InvalidParamError	orientation does not exist

Source code in prettyqt\widgets\progressbar.py

def set_orientation(self, orientation: constants.OrientationStr):
    """Set the orientation of the progress bar.

    Args:
        orientation: orientation for the progress bar

    Raises:
        InvalidParamError: orientation does not exist
    """
    if orientation not in constants.ORIENTATION:
        raise InvalidParamError(orientation, constants.ORIENTATION)
    self.setOrientation(constants.ORIENTATION[orientation])

set_range(start: int, end: int)

Source code in prettyqt\widgets\progressbar.py

def set_range(self, start: int, end: int):
    self.setRange(start, end)

set_text_direction(text_direction: TextDirectionStr)

Set the text direction of the layout.

Parameters:

Name	Type	Description	Default
text_direction	TextDirectionStr	text direction for the layout	required

Raises:

Type	Description
InvalidParamError	text direction does not exist

Source code in prettyqt\widgets\progressbar.py

def set_text_direction(self, text_direction: TextDirectionStr):
    """Set the text direction of the layout.

    Args:
        text_direction: text direction for the layout

    Raises:
        InvalidParamError: text direction does not exist
    """
    if text_direction not in TEXT_DIRECTIONS:
        raise InvalidParamError(text_direction, TEXT_DIRECTIONS)
    self.setTextDirection(TEXT_DIRECTIONS[text_direction])

set_value(value: int)

Source code in prettyqt\widgets\progressbar.py

def set_value(self, value: int):
    self.setValue(value)

ProgressDialog

Bases: widgets.DialogMixin, QtWidgets.QProgressDialog

Progress dialog.

Wrapper for QtWidgets.QProgressDialog

Source code in prettyqt\widgets\progressdialog.py

class ProgressDialog(widgets.DialogMixin, QtWidgets.QProgressDialog):
    """Progress dialog.

    Wrapper for QtWidgets.QProgressDialog
    """

    def __init__(self, parent: QtWidgets.QWidget | None = None):
        super().__init__(parent=parent)

        progress_bar = widgets.ProgressBar()
        progress_bar.setRange(0, 0)
        progress_bar.setTextVisible(False)
        self.setBar(progress_bar)

        self.set_icon("mdi.timer-sand-empty")
        self.set_modality("application")
        self.set_flags(
            minimize=False, maximize=False, close=False, stay_on_top=True, window=True
        )
        self.setCancelButton(None)  # type: ignore
        self.cancel()

    def show_message(self, message: str):
        self.setLabelText(message)
        self.show()

__init__(parent: QtWidgets.QWidget | None = None)

Source code in prettyqt\widgets\progressdialog.py

def __init__(self, parent: QtWidgets.QWidget | None = None):
    super().__init__(parent=parent)

    progress_bar = widgets.ProgressBar()
    progress_bar.setRange(0, 0)
    progress_bar.setTextVisible(False)
    self.setBar(progress_bar)

    self.set_icon("mdi.timer-sand-empty")
    self.set_modality("application")
    self.set_flags(
        minimize=False, maximize=False, close=False, stay_on_top=True, window=True
    )
    self.setCancelButton(None)  # type: ignore
    self.cancel()

show_message(message: str)

Source code in prettyqt\widgets\progressdialog.py

def show_message(self, message: str):
    self.setLabelText(message)
    self.show()

ProxyStyle

Bases: widgets.CommonStyleMixin, QtWidgets.QProxyStyle

Source code in prettyqt\widgets\proxystyle.py

class ProxyStyle(widgets.CommonStyleMixin, QtWidgets.QProxyStyle):
    pass

PushButton

Bases: PushButtonMixin, QtWidgets.QPushButton

Source code in prettyqt\widgets\pushbutton.py

class PushButton(PushButtonMixin, QtWidgets.QPushButton):
    pass

PushButtonMixin

Bases: widgets.AbstractButtonMixin

Source code in prettyqt\widgets\pushbutton.py

class PushButtonMixin(widgets.AbstractButtonMixin):
    value_changed = core.Signal(bool)

    def __init__(
        self,
        label: str | None = None,
        parent: QtWidgets.QWidget | None = None,
        callback: Callable | None = None,
    ):
        if label is None:
            label = ""
        super().__init__(label, parent)
        if callback:
            self.clicked.connect(callback)
        self.toggled.connect(self.value_changed)

value_changed = core.Signal(bool) class-attribute

__init__(label: str | None = None, parent: QtWidgets.QWidget | None = None, callback: Callable | None = None)

Source code in prettyqt\widgets\pushbutton.py

def __init__(
    self,
    label: str | None = None,
    parent: QtWidgets.QWidget | None = None,
    callback: Callable | None = None,
):
    if label is None:
        label = ""
    super().__init__(label, parent)
    if callback:
        self.clicked.connect(callback)
    self.toggled.connect(self.value_changed)

RadioButton

Bases: widgets.AbstractButtonMixin, QtWidgets.QRadioButton

Source code in prettyqt\widgets\radiobutton.py

class RadioButton(widgets.AbstractButtonMixin, QtWidgets.QRadioButton):
    value_changed = core.Signal(bool)

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.toggled.connect(self.value_changed)

value_changed = core.Signal(bool) class-attribute

__init__(*args, **kwargs)

Source code in prettyqt\widgets\radiobutton.py

def __init__(self, *args, **kwargs):
    super().__init__(*args, **kwargs)
    self.toggled.connect(self.value_changed)

RubberBand

Bases: RubberBandMixin, QtWidgets.QRubberBand

Source code in prettyqt\widgets\rubberband.py

class RubberBand(RubberBandMixin, QtWidgets.QRubberBand):
    pass

ScrollArea

Bases: widgets.AbstractScrollAreaMixin, QtWidgets.QScrollArea

Source code in prettyqt\widgets\scrollarea.py

class ScrollArea(widgets.AbstractScrollAreaMixin, QtWidgets.QScrollArea):
    def set_widget(self, widget: QtWidgets.QWidget):
        self.setWidget(widget)

set_widget(widget: QtWidgets.QWidget)

Source code in prettyqt\widgets\scrollarea.py

def set_widget(self, widget: QtWidgets.QWidget):
    self.setWidget(widget)

ScrollBar

Bases: ScrollBarMixin, QtWidgets.QScrollBar

Source code in prettyqt\widgets\scrollbar.py

class ScrollBar(ScrollBarMixin, QtWidgets.QScrollBar):
    pass

Scroller

Bases: core.ObjectMixin

Source code in prettyqt\widgets\scroller.py

class Scroller(core.ObjectMixin):
    def __init__(self, item: QtWidgets.QScroller):
        self.item = item

    def __getattr__(self, val):
        return getattr(self.item, val)

    def get_state(self) -> StateStr:
        """Return current state.

        Returns:
            state
        """
        return STATE.inverse[self.state()]

    def get_velocity(self) -> core.PointF:
        return core.PointF(self.velocity())

    def get_pixel_per_meter(self) -> core.PointF:
        return core.PointF(self.pixelPerMeter())

    def get_final_position(self) -> core.PointF:
        return core.PointF(self.finalPosition())

    def handle_input(
        self, input_type: InputStr, position: datatypes.PointFType, timestamp: int = 0
    ) -> bool:
        if isinstance(position, tuple):
            position = core.PointF(*position)
        if input_type not in INPUT:
            raise InvalidParamError(input_type, INPUT)
        return self.handleInput(INPUT[input_type], position, timestamp)

    def get_scroller_properties(self) -> widgets.ScrollerProperties:
        return widgets.ScrollerProperties(self.scrollerProperties())

    @classmethod
    def get_scroller(cls, obj: QtCore.QObject):
        return cls(QtWidgets.QScroller.scroller(obj))

    @staticmethod
    def grab_gesture(
        target: QtCore.QObject, gesture_type: ScrollGestureTypeStr = "touch"
    ) -> constants.GestureTypeStr:
        if gesture_type not in SCROLLER_GESTURE_TYPE:
            raise InvalidParamError(gesture_type, SCROLLER_GESTURE_TYPE)
        gesture = QtWidgets.QScroller.grabGesture(
            target, SCROLLER_GESTURE_TYPE[gesture_type]
        )
        if gesture >= 256:
            gesture -= 256
        return constants.GESTURE_TYPE.inverse[gesture]

    @staticmethod
    def grabbed_gesture(target: QtCore.QObject) -> constants.GestureTypeStr:
        return constants.GESTURE_TYPE.inverse[QtWidgets.QScroller.grabbedGesture(target)]

item = item instance-attribute

__getattr__(val)

Source code in prettyqt\widgets\scroller.py

def __getattr__(self, val):
    return getattr(self.item, val)

__init__(item: QtWidgets.QScroller)

Source code in prettyqt\widgets\scroller.py

def __init__(self, item: QtWidgets.QScroller):
    self.item = item

get_final_position() -> core.PointF

Source code in prettyqt\widgets\scroller.py

def get_final_position(self) -> core.PointF:
    return core.PointF(self.finalPosition())

get_pixel_per_meter() -> core.PointF

Source code in prettyqt\widgets\scroller.py

def get_pixel_per_meter(self) -> core.PointF:
    return core.PointF(self.pixelPerMeter())

get_scroller(obj: QtCore.QObject) classmethod

Source code in prettyqt\widgets\scroller.py

@classmethod
def get_scroller(cls, obj: QtCore.QObject):
    return cls(QtWidgets.QScroller.scroller(obj))

get_scroller_properties() -> widgets.ScrollerProperties

Source code in prettyqt\widgets\scroller.py

def get_scroller_properties(self) -> widgets.ScrollerProperties:
    return widgets.ScrollerProperties(self.scrollerProperties())

get_state() -> StateStr

Return current state.

Returns:

Type	Description
StateStr	state

Source code in prettyqt\widgets\scroller.py

def get_state(self) -> StateStr:
    """Return current state.

    Returns:
        state
    """
    return STATE.inverse[self.state()]

get_velocity() -> core.PointF

Source code in prettyqt\widgets\scroller.py

def get_velocity(self) -> core.PointF:
    return core.PointF(self.velocity())

grab_gesture(target: QtCore.QObject, gesture_type: ScrollGestureTypeStr = 'touch') -> constants.GestureTypeStr staticmethod

Source code in prettyqt\widgets\scroller.py

@staticmethod
def grab_gesture(
    target: QtCore.QObject, gesture_type: ScrollGestureTypeStr = "touch"
) -> constants.GestureTypeStr:
    if gesture_type not in SCROLLER_GESTURE_TYPE:
        raise InvalidParamError(gesture_type, SCROLLER_GESTURE_TYPE)
    gesture = QtWidgets.QScroller.grabGesture(
        target, SCROLLER_GESTURE_TYPE[gesture_type]
    )
    if gesture >= 256:
        gesture -= 256
    return constants.GESTURE_TYPE.inverse[gesture]

grabbed_gesture(target: QtCore.QObject) -> constants.GestureTypeStr staticmethod

Source code in prettyqt\widgets\scroller.py

@staticmethod
def grabbed_gesture(target: QtCore.QObject) -> constants.GestureTypeStr:
    return constants.GESTURE_TYPE.inverse[QtWidgets.QScroller.grabbedGesture(target)]

handle_input(input_type: InputStr, position: datatypes.PointFType, timestamp: int = 0) -> bool

Source code in prettyqt\widgets\scroller.py

def handle_input(
    self, input_type: InputStr, position: datatypes.PointFType, timestamp: int = 0
) -> bool:
    if isinstance(position, tuple):
        position = core.PointF(*position)
    if input_type not in INPUT:
        raise InvalidParamError(input_type, INPUT)
    return self.handleInput(INPUT[input_type], position, timestamp)

ScrollerProperties

Bases: QtWidgets.QScrollerProperties

Source code in prettyqt\widgets\scrollerproperties.py

class ScrollerProperties(QtWidgets.QScrollerProperties):
    def __getitem__(self, metric: ScrollmetricStr):
        return self.get_scroll_metric(metric)

    def __setitem__(self, metric: ScrollmetricStr, value: Any):
        self.set_scroll_metric(metric, value)

    def keys(self):
        return SCROLL_METRIC.keys()

    def __iter__(self):
        return iter(SCROLL_METRIC.keys())

    def set_scroll_metric(self, metric: ScrollmetricStr, value: Any):
        """Set scroll metric.

        Args:
            metric: Scroll metric to set
            value: Value to set

        Raises:
            InvalidParamError: metric does not exist

        """
        if metric not in SCROLL_METRIC:
            raise InvalidParamError(metric, SCROLL_METRIC)
        self.setScrollMetric(SCROLL_METRIC[metric], value)

    def get_scroll_metric(self, metric: ScrollmetricStr) -> Any:
        """Return scroll metric.

        Args:
            metric: Scroll metric to get

        Raises:
            InvalidParamError: metric does not exist

        Returns:
            state
        """
        if metric not in SCROLL_METRIC:
            raise InvalidParamError(metric, SCROLL_METRIC)
        return self.scrollMetric(SCROLL_METRIC[metric])

    def get_scroll_metrics(self) -> dict:
        return {i: self.get_scroll_metric(i) for i in SCROLL_METRIC}

__getitem__(metric: ScrollmetricStr)

Source code in prettyqt\widgets\scrollerproperties.py

def __getitem__(self, metric: ScrollmetricStr):
    return self.get_scroll_metric(metric)

__iter__()

Source code in prettyqt\widgets\scrollerproperties.py

def __iter__(self):
    return iter(SCROLL_METRIC.keys())

__setitem__(metric: ScrollmetricStr, value: Any)

Source code in prettyqt\widgets\scrollerproperties.py

def __setitem__(self, metric: ScrollmetricStr, value: Any):
    self.set_scroll_metric(metric, value)

get_scroll_metric(metric: ScrollmetricStr) -> Any

Return scroll metric.

Parameters:

Name	Type	Description	Default
metric	ScrollmetricStr	Scroll metric to get	required

Raises:

Type	Description
InvalidParamError	metric does not exist

Returns:

Type	Description
Any	state

Source code in prettyqt\widgets\scrollerproperties.py

def get_scroll_metric(self, metric: ScrollmetricStr) -> Any:
    """Return scroll metric.

    Args:
        metric: Scroll metric to get

    Raises:
        InvalidParamError: metric does not exist

    Returns:
        state
    """
    if metric not in SCROLL_METRIC:
        raise InvalidParamError(metric, SCROLL_METRIC)
    return self.scrollMetric(SCROLL_METRIC[metric])

get_scroll_metrics() -> dict

Source code in prettyqt\widgets\scrollerproperties.py

def get_scroll_metrics(self) -> dict:
    return {i: self.get_scroll_metric(i) for i in SCROLL_METRIC}

keys()

Source code in prettyqt\widgets\scrollerproperties.py

def keys(self):
    return SCROLL_METRIC.keys()

set_scroll_metric(metric: ScrollmetricStr, value: Any)

Set scroll metric.

Parameters:

Name	Type	Description	Default
metric	ScrollmetricStr	Scroll metric to set	required
value	Any	Value to set	required

Raises:

Type	Description
InvalidParamError	metric does not exist

Source code in prettyqt\widgets\scrollerproperties.py

def set_scroll_metric(self, metric: ScrollmetricStr, value: Any):
    """Set scroll metric.

    Args:
        metric: Scroll metric to set
        value: Value to set

    Raises:
        InvalidParamError: metric does not exist

    """
    if metric not in SCROLL_METRIC:
        raise InvalidParamError(metric, SCROLL_METRIC)
    self.setScrollMetric(SCROLL_METRIC[metric], value)

Shortcut

Bases: core.ObjectMixin, QtWidgets.QShortcut

Source code in prettyqt\widgets\shortcut.py

class Shortcut(core.ObjectMixin, QtWidgets.QShortcut):
    def __str__(self):
        return self.key().toString()

    def serialize_field(self):
        return dict(
            auto_repeat=self.autoRepeat(),
            context=self.get_context(),
            enabled=self.isEnabled(),
            key=self.get_key(),
            whats_this=self.whatsThis(),
        )

    def set_context(self, context: constants.ContextStr):
        """Set shortcut context.

        Args:
            context: shortcut context

        Raises:
            InvalidParamError: shortcut context does not exist
        """
        if context not in constants.CONTEXT:
            raise InvalidParamError(context, constants.CONTEXT)
        self.setContext(constants.CONTEXT[context])

    def get_context(self) -> constants.ContextStr:
        """Return shortcut context.

        Returns:
            shortcut context
        """
        return constants.CONTEXT.inverse[self.context()]

    def get_key(self) -> gui.KeySequence:
        """Return the shortcut's key sequence.

        Returns:
            Key sequence
        """
        return gui.KeySequence(
            self.key().toString(), gui.KeySequence.SequenceFormat.PortableText
        )

__str__()

Source code in prettyqt\widgets\shortcut.py

def __str__(self):
    return self.key().toString()

get_context() -> constants.ContextStr

Return shortcut context.

Returns:

Type	Description
constants.ContextStr	shortcut context

Source code in prettyqt\widgets\shortcut.py

def get_context(self) -> constants.ContextStr:
    """Return shortcut context.

    Returns:
        shortcut context
    """
    return constants.CONTEXT.inverse[self.context()]

get_key() -> gui.KeySequence

Return the shortcut's key sequence.

Returns:

Type	Description
gui.KeySequence	Key sequence

Source code in prettyqt\widgets\shortcut.py

def get_key(self) -> gui.KeySequence:
    """Return the shortcut's key sequence.

    Returns:
        Key sequence
    """
    return gui.KeySequence(
        self.key().toString(), gui.KeySequence.SequenceFormat.PortableText
    )

serialize_field()

Source code in prettyqt\widgets\shortcut.py

def serialize_field(self):
    return dict(
        auto_repeat=self.autoRepeat(),
        context=self.get_context(),
        enabled=self.isEnabled(),
        key=self.get_key(),
        whats_this=self.whatsThis(),
    )

set_context(context: constants.ContextStr)

Set shortcut context.

Parameters:

Name	Type	Description	Default
context	constants.ContextStr	shortcut context	required

Raises:

Type	Description
InvalidParamError	shortcut context does not exist

Source code in prettyqt\widgets\shortcut.py

def set_context(self, context: constants.ContextStr):
    """Set shortcut context.

    Args:
        context: shortcut context

    Raises:
        InvalidParamError: shortcut context does not exist
    """
    if context not in constants.CONTEXT:
        raise InvalidParamError(context, constants.CONTEXT)
    self.setContext(constants.CONTEXT[context])

SizeGrip

Bases: widgets.WidgetMixin, QtWidgets.QSizeGrip

Source code in prettyqt\widgets\sizegrip.py

class SizeGrip(widgets.WidgetMixin, QtWidgets.QSizeGrip):
    pass

SizePolicy

Bases: prettyprinter.PrettyPrinter, QtWidgets.QSizePolicy

Source code in prettyqt\widgets\sizepolicy.py

class SizePolicy(prettyprinter.PrettyPrinter, QtWidgets.QSizePolicy):
    def __repr__(self) -> str:
        cls_name = type(self).__name__
        params = helpers.format_kwargs(self.__getstate__())
        return f"{cls_name}({params})"

    def __getstate__(self):
        return dict(
            has_height_for_width=self.hasHeightForWidth(),
            has_width_for_height=self.hasWidthForHeight(),
            horizontal_stretch=self.horizontalStretch(),
            vertical_stretch=self.verticalStretch(),
            horizontal_policy=self.get_horizontal_policy(),
            vertical_policy=self.get_vertical_policy(),
            retain_size_when_hidden=self.retainSizeWhenHidden(),
            control_type=self.get_control_type(),
        )

    def __setstate__(self, state: dict[str, Any]) -> None:
        self.setHeightForWidth(state["has_height_for_width"])
        self.setWidthForHeight(state["has_width_for_height"])
        self.setHorizontalStretch(state["horizontal_stretch"])
        self.setVerticalStretch(state["vertical_stretch"])
        self.set_horizontal_policy(state["horizontal_policy"])
        self.set_vertical_policy(state["vertical_policy"])
        self.setRetainSizeWhenHidden(state["retain_size_when_hidden"])
        self.set_control_type(state["control_type"])

    def __reduce__(self):
        return type(self), (), self.__getstate__()

    def serialize(self) -> dict[str, Any]:
        return self.__getstate__()

    @classmethod
    def clone(cls, qpol: QtWidgets.QSizePolicy) -> SizePolicy:
        pol = cls(qpol.horizontalPolicy(), qpol.verticalPolicy(), qpol.controlType())
        pol.setHeightForWidth(qpol.hasHeightForWidth())
        pol.setWidthForHeight(qpol.hasWidthForHeight())
        pol.setHorizontalStretch(qpol.horizontalStretch())
        pol.setVerticalStretch(qpol.verticalStretch())
        pol.setRetainSizeWhenHidden(qpol.retainSizeWhenHidden())
        return pol

    def get_horizontal_policy(self) -> SizePolicyStr:
        """Return size policy.

        Returns:
            horizontal size policy
        """
        return SIZE_POLICY.inverse[self.horizontalPolicy()]

    def set_horizontal_policy(self, policy: SizePolicyStr) -> None:
        """Set the horizontal policy.

        Args:
            policy: policy to set

        Raises:
            InvalidParamError: policy does not exist
        """
        self.setHorizontalPolicy(SIZE_POLICY[policy])

    def get_vertical_policy(self) -> SizePolicyStr:
        """Return size policy.

        Returns:
            vertical size policy

        """
        return SIZE_POLICY.inverse[self.verticalPolicy()]

    def set_vertical_policy(self, policy: SizePolicyStr) -> None:
        """Set the horizontal policy.

        Args:
            policy: policy to set

        Raises:
            InvalidParamError: policy does not exist
        """
        self.setVerticalPolicy(SIZE_POLICY[policy])

    def get_control_type(self) -> ControlTypeStr:
        """Return control type.

        Returns:
            control type
        """
        return CONTROL_TYPE.inverse[self.controlType()]

    def set_control_type(self, typ: ControlTypeStr) -> None:
        """Set the control type.

        Args:
            typ: control type to set

        Raises:
            InvalidParamError: control type does not exist
        """
        if typ not in CONTROL_TYPE:
            raise InvalidParamError(typ, CONTROL_TYPE)
        self.setControlType(CONTROL_TYPE[typ])

__getstate__()

Source code in prettyqt\widgets\sizepolicy.py

def __getstate__(self):
    return dict(
        has_height_for_width=self.hasHeightForWidth(),
        has_width_for_height=self.hasWidthForHeight(),
        horizontal_stretch=self.horizontalStretch(),
        vertical_stretch=self.verticalStretch(),
        horizontal_policy=self.get_horizontal_policy(),
        vertical_policy=self.get_vertical_policy(),
        retain_size_when_hidden=self.retainSizeWhenHidden(),
        control_type=self.get_control_type(),
    )

__reduce__()

Source code in prettyqt\widgets\sizepolicy.py

def __reduce__(self):
    return type(self), (), self.__getstate__()

__repr__() -> str

Source code in prettyqt\widgets\sizepolicy.py

def __repr__(self) -> str:
    cls_name = type(self).__name__
    params = helpers.format_kwargs(self.__getstate__())
    return f"{cls_name}({params})"

__setstate__(state: dict[str, Any]) -> None

Source code in prettyqt\widgets\sizepolicy.py

def __setstate__(self, state: dict[str, Any]) -> None:
    self.setHeightForWidth(state["has_height_for_width"])
    self.setWidthForHeight(state["has_width_for_height"])
    self.setHorizontalStretch(state["horizontal_stretch"])
    self.setVerticalStretch(state["vertical_stretch"])
    self.set_horizontal_policy(state["horizontal_policy"])
    self.set_vertical_policy(state["vertical_policy"])
    self.setRetainSizeWhenHidden(state["retain_size_when_hidden"])
    self.set_control_type(state["control_type"])

clone(qpol: QtWidgets.QSizePolicy) -> SizePolicy classmethod

Source code in prettyqt\widgets\sizepolicy.py

@classmethod
def clone(cls, qpol: QtWidgets.QSizePolicy) -> SizePolicy:
    pol = cls(qpol.horizontalPolicy(), qpol.verticalPolicy(), qpol.controlType())
    pol.setHeightForWidth(qpol.hasHeightForWidth())
    pol.setWidthForHeight(qpol.hasWidthForHeight())
    pol.setHorizontalStretch(qpol.horizontalStretch())
    pol.setVerticalStretch(qpol.verticalStretch())
    pol.setRetainSizeWhenHidden(qpol.retainSizeWhenHidden())
    return pol

get_control_type() -> ControlTypeStr

Return control type.

Returns:

Type	Description
ControlTypeStr	control type

Source code in prettyqt\widgets\sizepolicy.py

def get_control_type(self) -> ControlTypeStr:
    """Return control type.

    Returns:
        control type
    """
    return CONTROL_TYPE.inverse[self.controlType()]

get_horizontal_policy() -> SizePolicyStr

Return size policy.

Returns:

Type	Description
SizePolicyStr	horizontal size policy

Source code in prettyqt\widgets\sizepolicy.py

def get_horizontal_policy(self) -> SizePolicyStr:
    """Return size policy.

    Returns:
        horizontal size policy
    """
    return SIZE_POLICY.inverse[self.horizontalPolicy()]

get_vertical_policy() -> SizePolicyStr

Return size policy.

Returns:

Type	Description
SizePolicyStr	vertical size policy

Source code in prettyqt\widgets\sizepolicy.py

def get_vertical_policy(self) -> SizePolicyStr:
    """Return size policy.

    Returns:
        vertical size policy

    """
    return SIZE_POLICY.inverse[self.verticalPolicy()]

serialize() -> dict[str, Any]

Source code in prettyqt\widgets\sizepolicy.py

def serialize(self) -> dict[str, Any]:
    return self.__getstate__()

set_control_type(typ: ControlTypeStr) -> None

Set the control type.

Parameters:

Name	Type	Description	Default
typ	ControlTypeStr	control type to set	required

Raises:

Type	Description
InvalidParamError	control type does not exist

Source code in prettyqt\widgets\sizepolicy.py

def set_control_type(self, typ: ControlTypeStr) -> None:
    """Set the control type.

    Args:
        typ: control type to set

    Raises:
        InvalidParamError: control type does not exist
    """
    if typ not in CONTROL_TYPE:
        raise InvalidParamError(typ, CONTROL_TYPE)
    self.setControlType(CONTROL_TYPE[typ])

set_horizontal_policy(policy: SizePolicyStr) -> None

Set the horizontal policy.

Parameters:

Name	Type	Description	Default
policy	SizePolicyStr	policy to set	required

Raises:

Type	Description
InvalidParamError	policy does not exist

Source code in prettyqt\widgets\sizepolicy.py

def set_horizontal_policy(self, policy: SizePolicyStr) -> None:
    """Set the horizontal policy.

    Args:
        policy: policy to set

    Raises:
        InvalidParamError: policy does not exist
    """
    self.setHorizontalPolicy(SIZE_POLICY[policy])

set_vertical_policy(policy: SizePolicyStr) -> None

Set the horizontal policy.

Parameters:

Name	Type	Description	Default
policy	SizePolicyStr	policy to set	required

Raises:

Type	Description
InvalidParamError	policy does not exist

Source code in prettyqt\widgets\sizepolicy.py

def set_vertical_policy(self, policy: SizePolicyStr) -> None:
    """Set the horizontal policy.

    Args:
        policy: policy to set

    Raises:
        InvalidParamError: policy does not exist
    """
    self.setVerticalPolicy(SIZE_POLICY[policy])

Slider

Bases: widgets.AbstractSliderMixin, QtWidgets.QSlider

Source code in prettyqt\widgets\slider.py

class Slider(widgets.AbstractSliderMixin, QtWidgets.QSlider):
    value_changed = core.Signal(int)

    def __init__(
        self,
        orientation: (constants.OrientationStr | QtCore.Qt.Orientation) = "horizontal",
        parent: QtWidgets.QWidget | None = None,
    ):
        if isinstance(orientation, QtCore.Qt.Orientation):
            ori = orientation
        else:
            ori = constants.ORIENTATION[orientation]
        super().__init__(ori, parent)
        self.valueChanged.connect(self.on_value_change)

    def set_tick_position(self, position: TickPositionAllStr):
        """Set the tick position for the slider.

        For vertical orientation, "above" equals to "left" and "below" to "right".

        Args:
            position: position for the ticks
        """
        if position == "left":
            position = "above"
        elif position == "right":
            position = "below"
        elif position not in TICK_POSITION:
            raise InvalidParamError(position, TICK_POSITION)
        self.setTickPosition(TICK_POSITION[position])

    def get_tick_position(self) -> TickPositionStr:
        """Return tick position.

        Returns:
            tick position
        """
        return TICK_POSITION.inverse[self.tickPosition()]

value_changed = core.Signal(int) class-attribute

__init__(orientation: constants.OrientationStr | QtCore.Qt.Orientation = 'horizontal', parent: QtWidgets.QWidget | None = None)

Source code in prettyqt\widgets\slider.py

def __init__(
    self,
    orientation: (constants.OrientationStr | QtCore.Qt.Orientation) = "horizontal",
    parent: QtWidgets.QWidget | None = None,
):
    if isinstance(orientation, QtCore.Qt.Orientation):
        ori = orientation
    else:
        ori = constants.ORIENTATION[orientation]
    super().__init__(ori, parent)
    self.valueChanged.connect(self.on_value_change)

get_tick_position() -> TickPositionStr

Return tick position.

Returns:

Type	Description
TickPositionStr	tick position

Source code in prettyqt\widgets\slider.py

def get_tick_position(self) -> TickPositionStr:
    """Return tick position.

    Returns:
        tick position
    """
    return TICK_POSITION.inverse[self.tickPosition()]

set_tick_position(position: TickPositionAllStr)

Set the tick position for the slider.

For vertical orientation, "above" equals to "left" and "below" to "right".

Parameters:

Name	Type	Description	Default
position	TickPositionAllStr	position for the ticks	required

Source code in prettyqt\widgets\slider.py

def set_tick_position(self, position: TickPositionAllStr):
    """Set the tick position for the slider.

    For vertical orientation, "above" equals to "left" and "below" to "right".

    Args:
        position: position for the ticks
    """
    if position == "left":
        position = "above"
    elif position == "right":
        position = "below"
    elif position not in TICK_POSITION:
        raise InvalidParamError(position, TICK_POSITION)
    self.setTickPosition(TICK_POSITION[position])

SpacerItem

Bases: widgets.LayoutItemMixin, QtWidgets.QSpacerItem

Source code in prettyqt\widgets\spaceritem.py

class SpacerItem(widgets.LayoutItemMixin, QtWidgets.QSpacerItem):
    def __init__(
        self,
        w: int,
        h: int,
        h_policy: QtWidgets.QSizePolicy.Policy
        | widgets.sizepolicy.SizePolicyStr = "minimum",
        v_policy: QtWidgets.QSizePolicy.Policy
        | widgets.sizepolicy.SizePolicyStr = "minimum",
    ):
        if isinstance(h_policy, QtWidgets.QSizePolicy.Policy):
            h_pol = h_policy
        else:
            h_pol = widgets.sizepolicy.SIZE_POLICY[h_policy]
        if isinstance(v_policy, QtWidgets.QSizePolicy.Policy):
            v_pol = v_policy
        else:
            v_pol = widgets.sizepolicy.SIZE_POLICY[v_policy]
        super().__init__(w, h, h_pol, v_pol)

    def change_size(
        self,
        w: int,
        h: int,
        h_policy: widgets.sizepolicy.SizePolicyStr = "minimum",
        v_policy: widgets.sizepolicy.SizePolicyStr = "minimum",
    ):
        h_pol = widgets.sizepolicy.SIZE_POLICY[h_policy]
        v_pol = widgets.sizepolicy.SIZE_POLICY[v_policy]
        self.changeSize(w, h, h_pol, v_pol)

    def get_size_policy(self) -> widgets.SizePolicy:
        return widgets.SizePolicy.clone(self.sizePolicy())

__init__(w: int, h: int, h_policy: QtWidgets.QSizePolicy.Policy | widgets.sizepolicy.SizePolicyStr = 'minimum', v_policy: QtWidgets.QSizePolicy.Policy | widgets.sizepolicy.SizePolicyStr = 'minimum')

Source code in prettyqt\widgets\spaceritem.py

def __init__(
    self,
    w: int,
    h: int,
    h_policy: QtWidgets.QSizePolicy.Policy
    | widgets.sizepolicy.SizePolicyStr = "minimum",
    v_policy: QtWidgets.QSizePolicy.Policy
    | widgets.sizepolicy.SizePolicyStr = "minimum",
):
    if isinstance(h_policy, QtWidgets.QSizePolicy.Policy):
        h_pol = h_policy
    else:
        h_pol = widgets.sizepolicy.SIZE_POLICY[h_policy]
    if isinstance(v_policy, QtWidgets.QSizePolicy.Policy):
        v_pol = v_policy
    else:
        v_pol = widgets.sizepolicy.SIZE_POLICY[v_policy]
    super().__init__(w, h, h_pol, v_pol)

change_size(w: int, h: int, h_policy: widgets.sizepolicy.SizePolicyStr = 'minimum', v_policy: widgets.sizepolicy.SizePolicyStr = 'minimum')

Source code in prettyqt\widgets\spaceritem.py

def change_size(
    self,
    w: int,
    h: int,
    h_policy: widgets.sizepolicy.SizePolicyStr = "minimum",
    v_policy: widgets.sizepolicy.SizePolicyStr = "minimum",
):
    h_pol = widgets.sizepolicy.SIZE_POLICY[h_policy]
    v_pol = widgets.sizepolicy.SIZE_POLICY[v_policy]
    self.changeSize(w, h, h_pol, v_pol)

get_size_policy() -> widgets.SizePolicy

Source code in prettyqt\widgets\spaceritem.py

def get_size_policy(self) -> widgets.SizePolicy:
    return widgets.SizePolicy.clone(self.sizePolicy())

SpinBox

Bases: widgets.AbstractSpinBoxMixin, QtWidgets.QSpinBox

Source code in prettyqt\widgets\spinbox.py

class SpinBox(widgets.AbstractSpinBoxMixin, QtWidgets.QSpinBox):
    value_changed = core.Signal(int)

    def __init__(
        self,
        parent: QtWidgets.QWidget | None = None,
        min_value: int | None = None,
        max_value: int | None = None,
        default_value: int | None = None,
    ):
        super().__init__(parent)
        self.valueChanged.connect(self.value_changed)
        self.set_range(min_value, max_value)
        if default_value is not None:
            self.set_value(default_value)

    def set_range(self, start: int | None, end: int | None):
        if start is None:
            start = -2147483647
        if end is None:
            end = 2147483647
        self.setRange(start, end)

    def set_step_size(self, step_size):
        self.setSingleStep(step_size)

value_changed = core.Signal(int) class-attribute

__init__(parent: QtWidgets.QWidget | None = None, min_value: int | None = None, max_value: int | None = None, default_value: int | None = None)

Source code in prettyqt\widgets\spinbox.py

def __init__(
    self,
    parent: QtWidgets.QWidget | None = None,
    min_value: int | None = None,
    max_value: int | None = None,
    default_value: int | None = None,
):
    super().__init__(parent)
    self.valueChanged.connect(self.value_changed)
    self.set_range(min_value, max_value)
    if default_value is not None:
        self.set_value(default_value)

set_range(start: int | None, end: int | None)

Source code in prettyqt\widgets\spinbox.py

def set_range(self, start: int | None, end: int | None):
    if start is None:
        start = -2147483647
    if end is None:
        end = 2147483647
    self.setRange(start, end)

set_step_size(step_size)

Source code in prettyqt\widgets\spinbox.py

def set_step_size(self, step_size):
    self.setSingleStep(step_size)

SplashScreen

Bases: SplashScreenMixin, QtWidgets.QSplashScreen

Source code in prettyqt\widgets\splashscreen.py

class SplashScreen(SplashScreenMixin, QtWidgets.QSplashScreen):
    pass

Splitter

Bases: SplitterMixin, QtWidgets.QSplitter

Source code in prettyqt\widgets\splitter.py

class Splitter(SplitterMixin, QtWidgets.QSplitter):
    pass

SplitterHandle

Bases: widgets.WidgetMixin, QtWidgets.QSplitterHandle

Source code in prettyqt\widgets\splitterhandle.py

class SplitterHandle(widgets.WidgetMixin, QtWidgets.QSplitterHandle):
    def __init__(
        self,
        orientation: constants.OrientationStr | QtCore.Qt.Orientation,
        parent: QtWidgets.QSplitter,
    ):
        if isinstance(orientation, QtCore.Qt.Orientation):
            ori = orientation
        else:
            ori = constants.ORIENTATION[orientation]
        super().__init__(ori, parent)

    def set_orientation(self, orientation: constants.OrientationStr):
        """Set the orientation of the slider.

        Args:
            orientation: orientation for the slider

        Raises:
            InvalidParamError: orientation does not exist
        """
        if orientation not in constants.ORIENTATION:
            raise InvalidParamError(orientation, constants.ORIENTATION)
        self.setOrientation(constants.ORIENTATION[orientation])

    def get_orientation(self) -> constants.OrientationStr:
        """Return current orientation.

        Returns:
            orientation
        """
        return constants.ORIENTATION.inverse[self.orientation()]

__init__(orientation: constants.OrientationStr | QtCore.Qt.Orientation, parent: QtWidgets.QSplitter)

Source code in prettyqt\widgets\splitterhandle.py

def __init__(
    self,
    orientation: constants.OrientationStr | QtCore.Qt.Orientation,
    parent: QtWidgets.QSplitter,
):
    if isinstance(orientation, QtCore.Qt.Orientation):
        ori = orientation
    else:
        ori = constants.ORIENTATION[orientation]
    super().__init__(ori, parent)

get_orientation() -> constants.OrientationStr

Return current orientation.

Returns:

Type	Description
constants.OrientationStr	orientation

Source code in prettyqt\widgets\splitterhandle.py

def get_orientation(self) -> constants.OrientationStr:
    """Return current orientation.

    Returns:
        orientation
    """
    return constants.ORIENTATION.inverse[self.orientation()]

set_orientation(orientation: constants.OrientationStr)

Set the orientation of the slider.

Parameters:

Name	Type	Description	Default
orientation	constants.OrientationStr	orientation for the slider	required

Raises:

Type	Description
InvalidParamError	orientation does not exist

Source code in prettyqt\widgets\splitterhandle.py

def set_orientation(self, orientation: constants.OrientationStr):
    """Set the orientation of the slider.

    Args:
        orientation: orientation for the slider

    Raises:
        InvalidParamError: orientation does not exist
    """
    if orientation not in constants.ORIENTATION:
        raise InvalidParamError(orientation, constants.ORIENTATION)
    self.setOrientation(constants.ORIENTATION[orientation])

StackedLayout

Bases: widgets.LayoutMixin, QtWidgets.QStackedLayout

Source code in prettyqt\widgets\stackedlayout.py

class StackedLayout(widgets.LayoutMixin, QtWidgets.QStackedLayout):
    # def serialize_fields(self):
    #     return dict(items=self.get_children())

    # def __setstate__(self, state):
    #     for item in state["items"]:
    #         self.add(item)

    # def __reduce__(self):
    #     return type(self), (), self.__getstate__()

    def __add__(self, other: QtWidgets.QWidget | QtWidgets.QLayout):
        self.add(other)
        return self

    def set_current_widget(self, widget: QtWidgets.QWidget):
        self.setCurrentWidget(widget)

__add__(other: QtWidgets.QWidget | QtWidgets.QLayout)

Source code in prettyqt\widgets\stackedlayout.py

def __add__(self, other: QtWidgets.QWidget | QtWidgets.QLayout):
    self.add(other)
    return self

set_current_widget(widget: QtWidgets.QWidget)

Source code in prettyqt\widgets\stackedlayout.py

def set_current_widget(self, widget: QtWidgets.QWidget):
    self.setCurrentWidget(widget)

StackedWidget

Bases: widgets.FrameMixin, QtWidgets.QStackedWidget

Source code in prettyqt\widgets\stackedwidget.py

class StackedWidget(widgets.FrameMixin, QtWidgets.QStackedWidget):
    # def __setstate__(self, state):
    #     for item in state["items"]:
    #         self.add(item)

    # def __reduce__(self):
    #     return type(self), (), self.__getstate__()

    def __add__(self, other: QtWidgets.QWidget) -> StackedWidget:
        self.addWidget(other)
        return self

    def __getitem__(self, index: int) -> QtWidgets.QWidget:
        return self.widget(index)

    def __iter__(self) -> Iterator[QtWidgets.QWidget]:
        return iter(self.widget(i) for i in range(self.count()))

    def __len__(self):
        # needed for PySide2
        return self.count()

    def __contains__(self, item: QtWidgets.QWidget):
        return self.indexOf(item) >= 0

    def serialize_fields(self):
        return dict(items=list(self))

    def set_current_widget(self, widget: QtWidgets.QWidget):
        self.setCurrentWidget(widget)

__add__(other: QtWidgets.QWidget) -> StackedWidget

Source code in prettyqt\widgets\stackedwidget.py

def __add__(self, other: QtWidgets.QWidget) -> StackedWidget:
    self.addWidget(other)
    return self

__contains__(item: QtWidgets.QWidget)

Source code in prettyqt\widgets\stackedwidget.py

def __contains__(self, item: QtWidgets.QWidget):
    return self.indexOf(item) >= 0

__getitem__(index: int) -> QtWidgets.QWidget

Source code in prettyqt\widgets\stackedwidget.py

def __getitem__(self, index: int) -> QtWidgets.QWidget:
    return self.widget(index)

__iter__() -> Iterator[QtWidgets.QWidget]

Source code in prettyqt\widgets\stackedwidget.py

def __iter__(self) -> Iterator[QtWidgets.QWidget]:
    return iter(self.widget(i) for i in range(self.count()))

__len__()

Source code in prettyqt\widgets\stackedwidget.py

def __len__(self):
    # needed for PySide2
    return self.count()

serialize_fields()

Source code in prettyqt\widgets\stackedwidget.py

def serialize_fields(self):
    return dict(items=list(self))

set_current_widget(widget: QtWidgets.QWidget)

Source code in prettyqt\widgets\stackedwidget.py

def set_current_widget(self, widget: QtWidgets.QWidget):
    self.setCurrentWidget(widget)

StatusBar

Bases: widgets.WidgetMixin, QtWidgets.QStatusBar

Source code in prettyqt\widgets\statusbar.py

class StatusBar(widgets.WidgetMixin, QtWidgets.QStatusBar):
    def __init__(self, *args, **kwargs) -> None:
        super().__init__(*args, **kwargs)
        self.progress_bar = widgets.ProgressBar()

    def __add__(self, other: QtWidgets.QAction | QtWidgets.QWidget) -> StatusBar:
        match other:
            case QtWidgets.QAction():
                self.addAction(other)
                return self
            case QtWidgets.QWidget():
                self.addWidget(other)
                return self
            case _:
                raise TypeError(other)

    def setup_default_bar(self) -> None:
        # This is simply to show the bar
        self.progress_bar.hide()
        self.progress_bar.setRange(0, 0)
        self.progress_bar.setFixedSize(200, 20)
        self.progress_bar.setTextVisible(False)
        self.addPermanentWidget(self.progress_bar)

    def add_action(self, action: QtWidgets.QAction) -> None:
        self.addAction(action)

    def add_widget(self, widget: QtWidgets.QWidget, permanent: bool = False) -> None:
        if permanent:
            self.addPermanentWidget(widget)
        else:
            self.addWidget(widget)

    def show_message(self, message: str, timeout: int = 0) -> None:
        self.showMessage(message, timeout)

progress_bar = widgets.ProgressBar() instance-attribute

__add__(other: QtWidgets.QAction | QtWidgets.QWidget) -> StatusBar

Source code in prettyqt\widgets\statusbar.py

def __add__(self, other: QtWidgets.QAction | QtWidgets.QWidget) -> StatusBar:
    match other:
        case QtWidgets.QAction():
            self.addAction(other)
            return self
        case QtWidgets.QWidget():
            self.addWidget(other)
            return self
        case _:
            raise TypeError(other)

__init__(*args, **kwargs) -> None

Source code in prettyqt\widgets\statusbar.py

def __init__(self, *args, **kwargs) -> None:
    super().__init__(*args, **kwargs)
    self.progress_bar = widgets.ProgressBar()

add_action(action: QtWidgets.QAction) -> None

Source code in prettyqt\widgets\statusbar.py

def add_action(self, action: QtWidgets.QAction) -> None:
    self.addAction(action)

add_widget(widget: QtWidgets.QWidget, permanent: bool = False) -> None

Source code in prettyqt\widgets\statusbar.py

def add_widget(self, widget: QtWidgets.QWidget, permanent: bool = False) -> None:
    if permanent:
        self.addPermanentWidget(widget)
    else:
        self.addWidget(widget)

setup_default_bar() -> None

Source code in prettyqt\widgets\statusbar.py

def setup_default_bar(self) -> None:
    # This is simply to show the bar
    self.progress_bar.hide()
    self.progress_bar.setRange(0, 0)
    self.progress_bar.setFixedSize(200, 20)
    self.progress_bar.setTextVisible(False)
    self.addPermanentWidget(self.progress_bar)

show_message(message: str, timeout: int = 0) -> None

Source code in prettyqt\widgets\statusbar.py

def show_message(self, message: str, timeout: int = 0) -> None:
    self.showMessage(message, timeout)

Style

Bases: StyleMixin, QtWidgets.QStyle

Source code in prettyqt\widgets\style.py

class Style(StyleMixin, QtWidgets.QStyle):
    pass

StyleFactory

Bases: QtWidgets.QStyleFactory

Source code in prettyqt\widgets\stylefactory.py

class StyleFactory(QtWidgets.QStyleFactory):
    pass

StyleMixin

Bases: core.ObjectMixin

Source code in prettyqt\widgets\style.py

class StyleMixin(core.ObjectMixin):
    def draw_primitive(
        self,
        element: SimpleControlStr,
        option: QtWidgets.QStyleOption,
        painter: QtGui.QPainter,
        widget: QtWidgets.QWidget | None = None,
    ):
        if element not in PRIMITIVE_ELEMENT:
            raise InvalidParamError(element, PRIMITIVE_ELEMENT)
        self.drawPrimitive(PRIMITIVE_ELEMENT[element], option, painter, widget)

    def draw_control(
        self,
        control: ControlElementStr,
        option: QtWidgets.QStyleOption,
        painter: QtGui.QPainter,
        widget: QtWidgets.QWidget | None = None,
    ):
        if control not in CONTROL_ELEMENT:
            raise InvalidParamError(control, CONTROL_ELEMENT)
        self.drawPrimitive(CONTROL_ELEMENT[control], option, painter, widget)

    def get_layout_spacing(
        self,
        control_1: widgets.sizepolicy.ControlTypeStr,
        control_2: widgets.sizepolicy.ControlTypeStr,
        orientation: constants.OrientationStr,
        option_or_widget: QtCore.QWidgets.QStyleOption | QtWidgets.QWidget | None = None,
    ):
        c1 = widgets.sizepolicy.CONTROL_TYPE[control_1]
        c2 = widgets.sizepolicy.CONTROL_TYPE[control_2]
        o = constants.ORIENTATION[orientation]
        match option_or_widget:
            case QtWidgets.QWidget():
                return self.layoutSpacing(c1, c2, o, None, option_or_widget)
            case QtWidgets.QStyleOption() | None:
                return self.layoutSpacing(c1, c2, o, option_or_widget)
            case _:
                raise ValueError(option_or_widget)

draw_control(control: ControlElementStr, option: QtWidgets.QStyleOption, painter: QtGui.QPainter, widget: QtWidgets.QWidget | None = None)

Source code in prettyqt\widgets\style.py

def draw_control(
    self,
    control: ControlElementStr,
    option: QtWidgets.QStyleOption,
    painter: QtGui.QPainter,
    widget: QtWidgets.QWidget | None = None,
):
    if control not in CONTROL_ELEMENT:
        raise InvalidParamError(control, CONTROL_ELEMENT)
    self.drawPrimitive(CONTROL_ELEMENT[control], option, painter, widget)

draw_primitive(element: SimpleControlStr, option: QtWidgets.QStyleOption, painter: QtGui.QPainter, widget: QtWidgets.QWidget | None = None)

Source code in prettyqt\widgets\style.py

def draw_primitive(
    self,
    element: SimpleControlStr,
    option: QtWidgets.QStyleOption,
    painter: QtGui.QPainter,
    widget: QtWidgets.QWidget | None = None,
):
    if element not in PRIMITIVE_ELEMENT:
        raise InvalidParamError(element, PRIMITIVE_ELEMENT)
    self.drawPrimitive(PRIMITIVE_ELEMENT[element], option, painter, widget)

get_layout_spacing(control_1: widgets.sizepolicy.ControlTypeStr, control_2: widgets.sizepolicy.ControlTypeStr, orientation: constants.OrientationStr, option_or_widget: QtCore.QWidgets.QStyleOption | QtWidgets.QWidget | None = None)

Source code in prettyqt\widgets\style.py

def get_layout_spacing(
    self,
    control_1: widgets.sizepolicy.ControlTypeStr,
    control_2: widgets.sizepolicy.ControlTypeStr,
    orientation: constants.OrientationStr,
    option_or_widget: QtCore.QWidgets.QStyleOption | QtWidgets.QWidget | None = None,
):
    c1 = widgets.sizepolicy.CONTROL_TYPE[control_1]
    c2 = widgets.sizepolicy.CONTROL_TYPE[control_2]
    o = constants.ORIENTATION[orientation]
    match option_or_widget:
        case QtWidgets.QWidget():
            return self.layoutSpacing(c1, c2, o, None, option_or_widget)
        case QtWidgets.QStyleOption() | None:
            return self.layoutSpacing(c1, c2, o, option_or_widget)
        case _:
            raise ValueError(option_or_widget)

StyleOption

Bases: StyleOptionMixin, QtWidgets.QStyleOption

Source code in prettyqt\widgets\styleoption.py

class StyleOption(StyleOptionMixin, QtWidgets.QStyleOption):
    pass

StyleOptionButton

Bases: widgets.StyleOptionMixin, QtWidgets.QStyleOptionButton

Source code in prettyqt\widgets\styleoptionbutton.py

class StyleOptionButton(widgets.StyleOptionMixin, QtWidgets.QStyleOptionButton):
    pass

StyleOptionComboBox

Bases: widgets.StyleOptionComplexMixin, QtWidgets.QStyleOptionComboBox

Source code in prettyqt\widgets\styleoptioncombobox.py

class StyleOptionComboBox(
    widgets.StyleOptionComplexMixin, QtWidgets.QStyleOptionComboBox
):
    pass

StyleOptionComplex

Bases: StyleOptionComplexMixin, QtWidgets.QStyleOptionComplex

Source code in prettyqt\widgets\styleoptioncomplex.py

class StyleOptionComplex(StyleOptionComplexMixin, QtWidgets.QStyleOptionComplex):
    pass

StyleOptionComplexMixin

Bases: widgets.StyleOptionMixin

Source code in prettyqt\widgets\styleoptioncomplex.py

class StyleOptionComplexMixin(widgets.StyleOptionMixin):
    pass

StyleOptionDockWidget

Bases: widgets.StyleOptionMixin, QtWidgets.QStyleOptionDockWidget

Source code in prettyqt\widgets\styleoptiondockwidget.py

class StyleOptionDockWidget(widgets.StyleOptionMixin, QtWidgets.QStyleOptionDockWidget):
    pass

StyleOptionFocusRect

Bases: widgets.StyleOptionMixin, QtWidgets.QStyleOptionFocusRect

Source code in prettyqt\widgets\styleoptionfocusrect.py

class StyleOptionFocusRect(widgets.StyleOptionMixin, QtWidgets.QStyleOptionFocusRect):
    pass

StyleOptionFrame

Bases: widgets.StyleOptionMixin, QtWidgets.QStyleOptionFrame

Source code in prettyqt\widgets\styleoptionframe.py

class StyleOptionFrame(widgets.StyleOptionMixin, QtWidgets.QStyleOptionFrame):
    pass

StyleOptionGraphicsItem

Bases: widgets.StyleOptionMixin, QtWidgets.QStyleOptionGraphicsItem

Source code in prettyqt\widgets\styleoptiongraphicsitem.py

class StyleOptionGraphicsItem(
    widgets.StyleOptionMixin, QtWidgets.QStyleOptionGraphicsItem
):
    pass

StyleOptionGroupBox

Bases: widgets.StyleOptionComplex, QtWidgets.QStyleOptionGroupBox

Source code in prettyqt\widgets\styleoptiongroupbox.py

class StyleOptionGroupBox(widgets.StyleOptionComplex, QtWidgets.QStyleOptionGroupBox):
    pass

StyleOptionHeader

Bases: widgets.StyleOptionMixin, QtWidgets.QStyleOptionHeader

Source code in prettyqt\widgets\styleoptionheader.py

class StyleOptionHeader(widgets.StyleOptionMixin, QtWidgets.QStyleOptionHeader):
    pass

StyleOptionMenuItem

Bases: widgets.StyleOptionMixin, QtWidgets.QStyleOptionMenuItem

Source code in prettyqt\widgets\styleoptionmenuitem.py

class StyleOptionMenuItem(widgets.StyleOptionMixin, QtWidgets.QStyleOptionMenuItem):
    pass

StyleOptionMixin

Source code in prettyqt\widgets\styleoption.py

class StyleOptionMixin:
    @classmethod
    def based_on(cls, widget: QtWidgets.QWidget) -> StyleOption:
        opt = cls()
        opt.initFrom(widget)
        return opt

based_on(widget: QtWidgets.QWidget) -> StyleOption classmethod

Source code in prettyqt\widgets\styleoption.py

@classmethod
def based_on(cls, widget: QtWidgets.QWidget) -> StyleOption:
    opt = cls()
    opt.initFrom(widget)
    return opt

StyleOptionProgressBar

Bases: widgets.StyleOptionMixin, QtWidgets.QStyleOptionProgressBar

Source code in prettyqt\widgets\styleoptionprogressbar.py

class StyleOptionProgressBar(widgets.StyleOptionMixin, QtWidgets.QStyleOptionProgressBar):
    pass

StyleOptionRubberBand

Bases: widgets.StyleOptionMixin, QtWidgets.QStyleOptionRubberBand

Source code in prettyqt\widgets\styleoptionrubberband.py

class StyleOptionRubberBand(widgets.StyleOptionMixin, QtWidgets.QStyleOptionRubberBand):
    pass

StyleOptionSizeGrip

Bases: widgets.StyleOptionComplexMixin, QtWidgets.QStyleOptionSizeGrip

Source code in prettyqt\widgets\styleoptionsizegrip.py

class StyleOptionSizeGrip(
    widgets.StyleOptionComplexMixin, QtWidgets.QStyleOptionSizeGrip
):
    pass

StyleOptionSlider

Bases: widgets.StyleOptionComplexMixin, QtWidgets.QStyleOptionSlider

Source code in prettyqt\widgets\styleoptionslider.py

class StyleOptionSlider(widgets.StyleOptionComplexMixin, QtWidgets.QStyleOptionSlider):
    def is_horizontal(self) -> bool:
        """Check if silder is horizontal.

        Returns:
            True if horizontal, else False
        """
        return self.orientation == constants.HORIZONTAL

    def is_vertical(self) -> bool:
        """Check if silder is vertical.

        Returns:
            True if vertical, else False
        """
        return self.orientation == constants.VERTICAL

    def set_horizontal(self) -> None:
        """Set slider orientation to horizontal."""
        self.orientation = constants.HORIZONTAL

    def set_vertical(self) -> None:
        """Set slider orientation to vertical."""
        self.orientation = constants.VERTICAL

    def get_orientation(self) -> Literal["horizontal", "vertical"]:
        return "horizontal" if self.is_horizontal() else "vertical"

get_orientation() -> Literal['horizontal', 'vertical']

Source code in prettyqt\widgets\styleoptionslider.py

def get_orientation(self) -> Literal["horizontal", "vertical"]:
    return "horizontal" if self.is_horizontal() else "vertical"

is_horizontal() -> bool

Check if silder is horizontal.

Returns:

Type	Description
bool	True if horizontal, else False

Source code in prettyqt\widgets\styleoptionslider.py

def is_horizontal(self) -> bool:
    """Check if silder is horizontal.

    Returns:
        True if horizontal, else False
    """
    return self.orientation == constants.HORIZONTAL

is_vertical() -> bool

Check if silder is vertical.

Returns:

Type	Description
bool	True if vertical, else False

Source code in prettyqt\widgets\styleoptionslider.py

def is_vertical(self) -> bool:
    """Check if silder is vertical.

    Returns:
        True if vertical, else False
    """
    return self.orientation == constants.VERTICAL

set_horizontal() -> None

Set slider orientation to horizontal.

Source code in prettyqt\widgets\styleoptionslider.py

def set_horizontal(self) -> None:
    """Set slider orientation to horizontal."""
    self.orientation = constants.HORIZONTAL

set_vertical() -> None

Set slider orientation to vertical.

Source code in prettyqt\widgets\styleoptionslider.py

def set_vertical(self) -> None:
    """Set slider orientation to vertical."""
    self.orientation = constants.VERTICAL

StyleOptionSpinBox

Bases: widgets.StyleOptionComplex, QtWidgets.QStyleOptionSpinBox

Source code in prettyqt\widgets\styleoptionspinbox.py

class StyleOptionSpinBox(widgets.StyleOptionComplex, QtWidgets.QStyleOptionSpinBox):
    pass

StyleOptionTab

Bases: widgets.StyleOptionMixin, QtWidgets.QStyleOptionTab

Source code in prettyqt\widgets\styleoptiontab.py

class StyleOptionTab(widgets.StyleOptionMixin, QtWidgets.QStyleOptionTab):
    pass

StyleOptionTabBarBase

Bases: widgets.StyleOptionMixin, QtWidgets.QStyleOptionTabBarBase

Source code in prettyqt\widgets\styleoptiontabbarbase.py

class StyleOptionTabBarBase(widgets.StyleOptionMixin, QtWidgets.QStyleOptionTabBarBase):
    pass

StyleOptionTabWidgetFrame

Bases: widgets.StyleOptionMixin, QtWidgets.QStyleOptionTabWidgetFrame

Source code in prettyqt\widgets\styleoptiontabwidgetframe.py

class StyleOptionTabWidgetFrame(
    widgets.StyleOptionMixin, QtWidgets.QStyleOptionTabWidgetFrame
):
    pass

StyleOptionTitleBar

Bases: widgets.StyleOptionComplex, QtWidgets.QStyleOptionTitleBar

Source code in prettyqt\widgets\styleoptiontitlebar.py

class StyleOptionTitleBar(widgets.StyleOptionComplex, QtWidgets.QStyleOptionTitleBar):
    pass

StyleOptionToolBar

Bases: widgets.StyleOptionMixin, QtWidgets.QStyleOptionToolBar

Source code in prettyqt\widgets\styleoptiontoolbar.py

class StyleOptionToolBar(widgets.StyleOptionMixin, QtWidgets.QStyleOptionToolBar):
    pass

StyleOptionToolBox

Bases: widgets.StyleOptionMixin, QtWidgets.QStyleOptionToolBox

Source code in prettyqt\widgets\styleoptiontoolbox.py

class StyleOptionToolBox(widgets.StyleOptionMixin, QtWidgets.QStyleOptionToolBox):
    def set_selected_position(self, position: SelectedPositionStr):
        self.selectedPosition = SELECTED_POSITION[position]

    def get_selected_position(self) -> SelectedPositionStr:
        return SELECTED_POSITION.inverse[self.selectedPosition]

get_selected_position() -> SelectedPositionStr

Source code in prettyqt\widgets\styleoptiontoolbox.py

def get_selected_position(self) -> SelectedPositionStr:
    return SELECTED_POSITION.inverse[self.selectedPosition]

set_selected_position(position: SelectedPositionStr)

Source code in prettyqt\widgets\styleoptiontoolbox.py

def set_selected_position(self, position: SelectedPositionStr):
    self.selectedPosition = SELECTED_POSITION[position]

StyleOptionToolButton

Bases: widgets.StyleOptionComplex, QtWidgets.QStyleOptionToolButton

Source code in prettyqt\widgets\styleoptiontoolbutton.py

class StyleOptionToolButton(widgets.StyleOptionComplex, QtWidgets.QStyleOptionToolButton):
    pass

StyleOptionViewItem

Bases: widgets.StyleOptionMixin, QtWidgets.QStyleOptionViewItem

Source code in prettyqt\widgets\styleoptionviewitem.py

class StyleOptionViewItem(widgets.StyleOptionMixin, QtWidgets.QStyleOptionViewItem):
    pass

StylePainter

Bases: gui.PainterMixin, QtWidgets.QStylePainter

Source code in prettyqt\widgets\stylepainter.py

class StylePainter(gui.PainterMixin, QtWidgets.QStylePainter):
    def draw_complex_control(
        self,
        control: widgets.style.ComplexControlStr,
        option: QtWidgets.QStyleOptionComplex,
    ):
        self.drawComplexControl(widgets.style.COMPLEX_CONTROL[control], option)

draw_complex_control(control: widgets.style.ComplexControlStr, option: QtWidgets.QStyleOptionComplex)

Source code in prettyqt\widgets\stylepainter.py

def draw_complex_control(
    self,
    control: widgets.style.ComplexControlStr,
    option: QtWidgets.QStyleOptionComplex,
):
    self.drawComplexControl(widgets.style.COMPLEX_CONTROL[control], option)

StyledItemDelegate

Bases: widgets.AbstractItemDelegateMixin, QtWidgets.QStyledItemDelegate

Source code in prettyqt\widgets\styleditemdelegate.py

class StyledItemDelegate(
    widgets.AbstractItemDelegateMixin, QtWidgets.QStyledItemDelegate
):
    pass

SwipeGesture

Bases: SwipeGestureMixin, QtWidgets.QSwipeGesture

Source code in prettyqt\widgets\swipegesture.py

class SwipeGesture(SwipeGestureMixin, QtWidgets.QSwipeGesture):
    pass

SystemTrayIcon

Bases: core.ObjectMixin, QtWidgets.QSystemTrayIcon

Source code in prettyqt\widgets\systemtrayicon.py

class SystemTrayIcon(core.ObjectMixin, QtWidgets.QSystemTrayIcon):
    def set_icon(self, icon: datatypes.IconType):
        """Set the system tray icon.

        Args:
            icon: icon to use
        """
        icon = iconprovider.get_icon(icon)
        self.setIcon(icon)

    def show_message(
        self,
        title: str,
        message: str = "",
        icon: datatypes.IconType = None,
        timeout: int = 10,
    ):
        if icon is None:
            ico = gui.Icon()
        if icon in MESSAGE_ICONS:
            ico = MESSAGE_ICONS[icon]
        else:
            ico = iconprovider.get_icon(icon)
        self.showMessage(title, message, ico, timeout * 1000)

set_icon(icon: datatypes.IconType)

Set the system tray icon.

Parameters:

Name	Type	Description	Default
icon	datatypes.IconType	icon to use	required

Source code in prettyqt\widgets\systemtrayicon.py

def set_icon(self, icon: datatypes.IconType):
    """Set the system tray icon.

    Args:
        icon: icon to use
    """
    icon = iconprovider.get_icon(icon)
    self.setIcon(icon)

show_message(title: str, message: str = '', icon: datatypes.IconType = None, timeout: int = 10)

Source code in prettyqt\widgets\systemtrayicon.py

def show_message(
    self,
    title: str,
    message: str = "",
    icon: datatypes.IconType = None,
    timeout: int = 10,
):
    if icon is None:
        ico = gui.Icon()
    if icon in MESSAGE_ICONS:
        ico = MESSAGE_ICONS[icon]
    else:
        ico = iconprovider.get_icon(icon)
    self.showMessage(title, message, ico, timeout * 1000)

TabBar

Bases: TabBarMixin, QtWidgets.QTabBar

Source code in prettyqt\widgets\tabbar.py

class TabBar(TabBarMixin, QtWidgets.QTabBar):
    pass

TabWidget

Bases: widgets.WidgetMixin, QtWidgets.QTabWidget

Widget for managing the tabs section.

Source code in prettyqt\widgets\tabwidget.py

class TabWidget(widgets.WidgetMixin, QtWidgets.QTabWidget):
    """Widget for managing the tabs section."""

    def __init__(
        self,
        parent: QtWidgets.QWidget | None = None,
        closable: bool = False,
        detachable: bool = False,
    ) -> None:
        # Basic initalization
        super().__init__(parent)
        self.tabCloseRequested.connect(self.remove_tab)
        self.tab_bar = widgets.TabBar(self)

        self.setTabBar(self.tab_bar)

        # Used to keep a reference to detached tabs since their QMainWindow
        # does not have a parent
        self.detached_tabs: dict[str, DetachedTab] = {}
        if detachable:
            self.set_detachable()
        self.set_closable(closable)

    def __len__(self) -> int:
        return self.count()

    def __getitem__(self, index: int) -> QtWidgets.QWidget:
        if isinstance(index, int):
            return self.widget(index)
        result = self.findChild(QtWidgets.QWidget, index)
        if result is None:
            raise KeyError("Widget not found")
        return result

    def __contains__(self, item: QtWidgets.QWidget):
        return self.indexOf(item) >= 0

    # def serialize_fields(self):
    #     return dict(
    #         tabbar=self.tabBar(),
    #         widgets=self.get_children(),
    #         movable=self.isMovable(),
    #         document_mode=self.documentMode(),
    #         current_index=self.currentIndex(),
    #         tab_shape=self.get_tab_shape(),
    #         # elide_mode=self.get_elide_mode(),
    #         icon_size=self.iconSize(),
    #         tab_position=self.get_tab_position(),
    #     )

    # def __setstate__(self, state):
    #     super().__setstate__(state)
    #     self.setTabBar(state["tabbar"])
    #     self.setDocumentMode(state.get("document_mode", False))
    #     self.setMovable(state.get("movable", False))
    #     self.set_tab_shape(state.get("tab_shape", "rounded"))
    #     self.setIconSize(state["icon_size"])
    #     for widget, name, icon, tooltip, whatsthis in state["widgets"]:
    #         i = self.add_tab(widget, name, icon)
    #         self.setTabToolTip(i, tooltip)
    #         self.setTabWhatsThis(i, whatsthis)
    #     self.setCurrentIndex(state.get("index", 0))

    # def __reduce__(self):
    #     return type(self), (), self.__getstate__()

    def update_tab_bar_visibility(self):
        """Update visibility of the tabBar depending of the number of tabs.

        0 or 1 tab -> tabBar hidden, 2+ tabs - >tabBar visible
        need to be called explicitly, or be connected to tabInserted/tabRemoved
        """
        self.tabBar().setVisible(self.count() > 1)

    def set_icon_size(self, size: int | datatypes.SizeType):
        """Set size of the icons."""
        if isinstance(size, int):
            size = core.Size(size, size)
        elif isinstance(size, tuple):
            size = core.Size(*size)
        self.setIconSize(size)

    def set_document_mode(self, state: bool = True) -> None:
        self.setDocumentMode(state)

    def set_tab_shape(self, shape: TabShapeStr):
        """Set tab shape for the tabwidget.

        Args:
            shape: tab shape to use

        Raises:
            InvalidParamError: tab shape does not exist
        """
        if shape not in TAB_SHAPES:
            raise InvalidParamError(shape, TAB_SHAPES)
        self.setTabShape(TAB_SHAPES[shape])

    def get_tab_shape(self) -> TabShapeStr:
        """Return tab shape.

        Returns:
            tab shape
        """
        return TAB_SHAPES.inverse[self.tabShape()]

    def set_tab_position(self, position: TabPositionStr):
        """Set tab position for the tabwidget.

        Args:
            position: tab position to use

        Raises:
            InvalidParamError: tab position does not exist
        """
        if position not in TAB_POSITION:
            raise InvalidParamError(position, TAB_POSITION)
        self.setTabPosition(TAB_POSITION[position])

    def get_tab_position(self) -> TabPositionStr:
        """Return tab position.

        Returns:
            tab position
        """
        return TAB_POSITION.inverse[self.tabPosition()]

    def get_children(self) -> list[tuple]:
        return [
            (
                self.widget(i),
                self.tabText(i),
                self.tab_icon(i),
                self.tabToolTip(i),
                self.tabWhatsThis(i),
            )
            for i in range(self.count())
        ]

    def tab_icon(self, i: int) -> gui.Icon | None:
        icon = self.tabIcon(i)
        return None if icon.isNull() else gui.Icon(icon)

    def set_detachable(self):
        self.tab_bar.on_detach.connect(self.detach_tab)
        core.CoreApplication.call_on_exit(self.close_detached_tabs)
        self.setMovable(True)

    def set_closable(self, closable: bool = True):
        self.setTabsClosable(closable)

    @core.Slot(int, QtCore.QPoint)
    def detach_tab(self, index: int, point: datatypes.PointType):
        """Detach tab by removing its contents and placing them in a DetachedTab window.

        Args:
            index (int): index location of the tab to be detached
            point (QtCore.QPoint): screen pos for creating the new DetachedTab window

        """
        # Get the tab content
        if isinstance(point, tuple):
            point = QtCore.QPoint(*point)
        name = self.tabText(index)
        icon = self.tab_icon(index) or self.window().windowIcon()
        widget = self.widget(index)

        try:
            widget_rect = widget.frameGeometry()
        except AttributeError:
            return

        # Create a new detached tab window
        detached_tab = DetachedTab(name, widget)
        detached_tab.set_modality("none")
        detached_tab.set_icon(icon)
        detached_tab.setGeometry(widget_rect)
        detached_tab.on_close.connect(self.attach_tab)
        detached_tab.move(point)
        detached_tab.show()

        # Create a reference to maintain access to the detached tab
        self.detached_tabs[name] = detached_tab

    def add_tab(
        self,
        item: QtWidgets.QWidget | QtWidgets.QLayout,
        label: str,
        icon: datatypes.IconType = None,
        position: int | None = None,
        show: bool = False,
    ) -> int:
        if isinstance(item, QtWidgets.QLayout):
            widget = widgets.Widget()
            widget.set_layout(item)
        else:
            widget = item
        if position is None:
            position = len(self)
        if not icon:
            index = self.insertTab(position, widget, label)
        else:
            icon = iconprovider.get_icon(icon)
            index = self.insertTab(position, widget, icon, label)
        if show:
            self.setCurrentIndex(index)
        return index

    def attach_tab(
        self,
        widget: QtWidgets.QWidget | QtWidgets.QLayout,
        name: str,
        icon: datatypes.IconType = None,
        insert_at: int | None = None,
    ):
        """Re-attach tab.

        Re-attach the tab by removing the content from the DetachedTab window,
        closing it, and placing the content back into the DetachableTabWidget.

        Args:
            widget (Union[QtWidgets.QWidget, QtWidgets.QLayout]): the content widget
                from the DetachedTab window
            name (str): the name of the detached tab
            icon (datatypes.IconType, optional): the window icon for the detached tab
            insert_at (Optional[int], optional): insert the re-attached tab at the
                given index
        """
        widget.setParent(self)

        # Remove the reference
        del self.detached_tabs[name]

        # Determine if the given image and the main window icon are the same.
        # If they are, then do not add the icon to the tab
        self.add_tab(widget, name, icon=icon, position=insert_at, show=True)

    def close_detached_tabs(self):
        """Close all tabs that are currently detached."""
        tabs = list(self.detached_tabs.values())
        for tab in tabs:
            tab.close()

    @core.Slot(int)
    def remove_tab(self, index: int):
        widget = self.widget(index)
        self.removeTab(index)
        if widget is not None:
            widget.deleteLater()

    @core.Slot(QtWidgets.QWidget, str)
    def open_widget(self, widget: QtWidgets.QWidget, title: str = "Unnamed"):
        """Create a tab containing delivered widget."""
        self.add_tab(widget, title, icon="mdi.widgets", show=True)

    def set_tab(self, index: int, position: str, widget: QtWidgets.QWidget | None = None):
        self.tabBar().set_tab(index, position, widget)

detached_tabs: dict[str, DetachedTab] = {} instance-attribute

tab_bar = widgets.TabBar(self) instance-attribute

__contains__(item: QtWidgets.QWidget)

Source code in prettyqt\widgets\tabwidget.py

def __contains__(self, item: QtWidgets.QWidget):
    return self.indexOf(item) >= 0

__getitem__(index: int) -> QtWidgets.QWidget

Source code in prettyqt\widgets\tabwidget.py

def __getitem__(self, index: int) -> QtWidgets.QWidget:
    if isinstance(index, int):
        return self.widget(index)
    result = self.findChild(QtWidgets.QWidget, index)
    if result is None:
        raise KeyError("Widget not found")
    return result

__init__(parent: QtWidgets.QWidget | None = None, closable: bool = False, detachable: bool = False) -> None

Source code in prettyqt\widgets\tabwidget.py

def __init__(
    self,
    parent: QtWidgets.QWidget | None = None,
    closable: bool = False,
    detachable: bool = False,
) -> None:
    # Basic initalization
    super().__init__(parent)
    self.tabCloseRequested.connect(self.remove_tab)
    self.tab_bar = widgets.TabBar(self)

    self.setTabBar(self.tab_bar)

    # Used to keep a reference to detached tabs since their QMainWindow
    # does not have a parent
    self.detached_tabs: dict[str, DetachedTab] = {}
    if detachable:
        self.set_detachable()
    self.set_closable(closable)

__len__() -> int

Source code in prettyqt\widgets\tabwidget.py

def __len__(self) -> int:
    return self.count()

add_tab(item: QtWidgets.QWidget | QtWidgets.QLayout, label: str, icon: datatypes.IconType = None, position: int | None = None, show: bool = False) -> int

Source code in prettyqt\widgets\tabwidget.py

def add_tab(
    self,
    item: QtWidgets.QWidget | QtWidgets.QLayout,
    label: str,
    icon: datatypes.IconType = None,
    position: int | None = None,
    show: bool = False,
) -> int:
    if isinstance(item, QtWidgets.QLayout):
        widget = widgets.Widget()
        widget.set_layout(item)
    else:
        widget = item
    if position is None:
        position = len(self)
    if not icon:
        index = self.insertTab(position, widget, label)
    else:
        icon = iconprovider.get_icon(icon)
        index = self.insertTab(position, widget, icon, label)
    if show:
        self.setCurrentIndex(index)
    return index

attach_tab(widget: QtWidgets.QWidget | QtWidgets.QLayout, name: str, icon: datatypes.IconType = None, insert_at: int | None = None)

Re-attach tab.

Re-attach the tab by removing the content from the DetachedTab window, closing it, and placing the content back into the DetachableTabWidget.

Parameters:

Name	Type	Description	Default
widget	Union[QtWidgets.QWidget, QtWidgets.QLayout]	the content widget from the DetachedTab window	required
name	str	the name of the detached tab	required
icon	datatypes.IconType	the window icon for the detached tab	None
insert_at	Optional[int]	insert the re-attached tab at the given index	None

Source code in prettyqt\widgets\tabwidget.py

def attach_tab(
    self,
    widget: QtWidgets.QWidget | QtWidgets.QLayout,
    name: str,
    icon: datatypes.IconType = None,
    insert_at: int | None = None,
):
    """Re-attach tab.

    Re-attach the tab by removing the content from the DetachedTab window,
    closing it, and placing the content back into the DetachableTabWidget.

    Args:
        widget (Union[QtWidgets.QWidget, QtWidgets.QLayout]): the content widget
            from the DetachedTab window
        name (str): the name of the detached tab
        icon (datatypes.IconType, optional): the window icon for the detached tab
        insert_at (Optional[int], optional): insert the re-attached tab at the
            given index
    """
    widget.setParent(self)

    # Remove the reference
    del self.detached_tabs[name]

    # Determine if the given image and the main window icon are the same.
    # If they are, then do not add the icon to the tab
    self.add_tab(widget, name, icon=icon, position=insert_at, show=True)

close_detached_tabs()

Close all tabs that are currently detached.

Source code in prettyqt\widgets\tabwidget.py

def close_detached_tabs(self):
    """Close all tabs that are currently detached."""
    tabs = list(self.detached_tabs.values())
    for tab in tabs:
        tab.close()

detach_tab(index: int, point: datatypes.PointType)

Detach tab by removing its contents and placing them in a DetachedTab window.

Parameters:

Name	Type	Description	Default
index	int	index location of the tab to be detached	required
point	QtCore.QPoint	screen pos for creating the new DetachedTab window	required

Source code in prettyqt\widgets\tabwidget.py

@core.Slot(int, QtCore.QPoint)
def detach_tab(self, index: int, point: datatypes.PointType):
    """Detach tab by removing its contents and placing them in a DetachedTab window.

    Args:
        index (int): index location of the tab to be detached
        point (QtCore.QPoint): screen pos for creating the new DetachedTab window

    """
    # Get the tab content
    if isinstance(point, tuple):
        point = QtCore.QPoint(*point)
    name = self.tabText(index)
    icon = self.tab_icon(index) or self.window().windowIcon()
    widget = self.widget(index)

    try:
        widget_rect = widget.frameGeometry()
    except AttributeError:
        return

    # Create a new detached tab window
    detached_tab = DetachedTab(name, widget)
    detached_tab.set_modality("none")
    detached_tab.set_icon(icon)
    detached_tab.setGeometry(widget_rect)
    detached_tab.on_close.connect(self.attach_tab)
    detached_tab.move(point)
    detached_tab.show()

    # Create a reference to maintain access to the detached tab
    self.detached_tabs[name] = detached_tab

get_children() -> list[tuple]

Source code in prettyqt\widgets\tabwidget.py

def get_children(self) -> list[tuple]:
    return [
        (
            self.widget(i),
            self.tabText(i),
            self.tab_icon(i),
            self.tabToolTip(i),
            self.tabWhatsThis(i),
        )
        for i in range(self.count())
    ]

get_tab_position() -> TabPositionStr

Return tab position.

Returns:

Type	Description
TabPositionStr	tab position

Source code in prettyqt\widgets\tabwidget.py

def get_tab_position(self) -> TabPositionStr:
    """Return tab position.

    Returns:
        tab position
    """
    return TAB_POSITION.inverse[self.tabPosition()]

get_tab_shape() -> TabShapeStr

Return tab shape.

Returns:

Type	Description
TabShapeStr	tab shape

Source code in prettyqt\widgets\tabwidget.py

def get_tab_shape(self) -> TabShapeStr:
    """Return tab shape.

    Returns:
        tab shape
    """
    return TAB_SHAPES.inverse[self.tabShape()]

open_widget(widget: QtWidgets.QWidget, title: str = 'Unnamed')

Create a tab containing delivered widget.

Source code in prettyqt\widgets\tabwidget.py

@core.Slot(QtWidgets.QWidget, str)
def open_widget(self, widget: QtWidgets.QWidget, title: str = "Unnamed"):
    """Create a tab containing delivered widget."""
    self.add_tab(widget, title, icon="mdi.widgets", show=True)

remove_tab(index: int)

Source code in prettyqt\widgets\tabwidget.py

@core.Slot(int)
def remove_tab(self, index: int):
    widget = self.widget(index)
    self.removeTab(index)
    if widget is not None:
        widget.deleteLater()

set_closable(closable: bool = True)

Source code in prettyqt\widgets\tabwidget.py

def set_closable(self, closable: bool = True):
    self.setTabsClosable(closable)

set_detachable()

Source code in prettyqt\widgets\tabwidget.py

def set_detachable(self):
    self.tab_bar.on_detach.connect(self.detach_tab)
    core.CoreApplication.call_on_exit(self.close_detached_tabs)
    self.setMovable(True)

set_document_mode(state: bool = True) -> None

Source code in prettyqt\widgets\tabwidget.py

def set_document_mode(self, state: bool = True) -> None:
    self.setDocumentMode(state)

set_icon_size(size: int | datatypes.SizeType)

Set size of the icons.

Source code in prettyqt\widgets\tabwidget.py

def set_icon_size(self, size: int | datatypes.SizeType):
    """Set size of the icons."""
    if isinstance(size, int):
        size = core.Size(size, size)
    elif isinstance(size, tuple):
        size = core.Size(*size)
    self.setIconSize(size)

set_tab(index: int, position: str, widget: QtWidgets.QWidget | None = None)

Source code in prettyqt\widgets\tabwidget.py

def set_tab(self, index: int, position: str, widget: QtWidgets.QWidget | None = None):
    self.tabBar().set_tab(index, position, widget)

set_tab_position(position: TabPositionStr)

Set tab position for the tabwidget.

Parameters:

Name	Type	Description	Default
position	TabPositionStr	tab position to use	required

Raises:

Type	Description
InvalidParamError	tab position does not exist

Source code in prettyqt\widgets\tabwidget.py

def set_tab_position(self, position: TabPositionStr):
    """Set tab position for the tabwidget.

    Args:
        position: tab position to use

    Raises:
        InvalidParamError: tab position does not exist
    """
    if position not in TAB_POSITION:
        raise InvalidParamError(position, TAB_POSITION)
    self.setTabPosition(TAB_POSITION[position])

set_tab_shape(shape: TabShapeStr)

Set tab shape for the tabwidget.

Parameters:

Name	Type	Description	Default
shape	TabShapeStr	tab shape to use	required

Raises:

Type	Description
InvalidParamError	tab shape does not exist

Source code in prettyqt\widgets\tabwidget.py

def set_tab_shape(self, shape: TabShapeStr):
    """Set tab shape for the tabwidget.

    Args:
        shape: tab shape to use

    Raises:
        InvalidParamError: tab shape does not exist
    """
    if shape not in TAB_SHAPES:
        raise InvalidParamError(shape, TAB_SHAPES)
    self.setTabShape(TAB_SHAPES[shape])

tab_icon(i: int) -> gui.Icon | None

Source code in prettyqt\widgets\tabwidget.py

def tab_icon(self, i: int) -> gui.Icon | None:
    icon = self.tabIcon(i)
    return None if icon.isNull() else gui.Icon(icon)

update_tab_bar_visibility()

Update visibility of the tabBar depending of the number of tabs.

0 or 1 tab -> tabBar hidden, 2+ tabs - >tabBar visible need to be called explicitly, or be connected to tabInserted/tabRemoved

Source code in prettyqt\widgets\tabwidget.py

def update_tab_bar_visibility(self):
    """Update visibility of the tabBar depending of the number of tabs.

    0 or 1 tab -> tabBar hidden, 2+ tabs - >tabBar visible
    need to be called explicitly, or be connected to tabInserted/tabRemoved
    """
    self.tabBar().setVisible(self.count() > 1)

TableView

Bases: TableViewMixin, QtWidgets.QTableView

Source code in prettyqt\widgets\tableview.py

class TableView(TableViewMixin, QtWidgets.QTableView):
    pass

TableViewMixin

Bases: widgets.AbstractItemViewMixin

Source code in prettyqt\widgets\tableview.py

class TableViewMixin(widgets.AbstractItemViewMixin):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        class_name = type(self).__name__
        self.set_id(class_name)
        self.setHorizontalHeader(widgets.HeaderView("horizontal", parent=self))
        self.setVerticalHeader(widgets.HeaderView("vertical", parent=self))
        self.setAlternatingRowColors(True)
        self.setWordWrap(False)

    @property
    def h_header(self):
        return self.horizontalHeader()

    @h_header.setter
    def h_header(self, header):
        self.setHorizontalHeader(header)

    @property
    def v_header(self):
        return self.verticalHeader()

    @v_header.setter
    def v_header(self, header):
        self.setVerticalHeader(header)

    def setup_list_style(self):
        self.set_selection_behaviour("rows")
        self.h_header.setStretchLastSection(True)
        self.v_header.set_resize_mode("fixed")
        self.v_header.set_default_section_size(28)

    def adapt_sizes(self):
        model = self.model()
        if model is not None and (model.rowCount() * model.columnCount()) < 1000:
            self.resizeColumnsToContents()
        else:
            self.h_header.resize_sections("interactive")

    def sort_by_column(self, column: int | None, ascending: bool = True):
        column = -1 if column is None else column
        order = constants.ASCENDING if ascending else constants.DESCENDING
        self.sortByColumn(column, order)

    def set_grid_style(self, style: constants.PenStyleStr):
        """Set grid style.

        Args:
            style: grid style to use

        Raises:
            InvalidParamError: invalid grid style
        """
        if style not in constants.PEN_STYLE:
            raise InvalidParamError(style, constants.PEN_STYLE)
        self.setGridStyle(constants.PEN_STYLE[style])

    def get_grid_style(self) -> constants.PenStyleStr:
        """Return grid style.

        Returns:
            grid style
        """
        return constants.PEN_STYLE.inverse[self.gridStyle()]

h_header writable property

v_header writable property

__init__(*args, **kwargs)

Source code in prettyqt\widgets\tableview.py

def __init__(self, *args, **kwargs):
    super().__init__(*args, **kwargs)
    class_name = type(self).__name__
    self.set_id(class_name)
    self.setHorizontalHeader(widgets.HeaderView("horizontal", parent=self))
    self.setVerticalHeader(widgets.HeaderView("vertical", parent=self))
    self.setAlternatingRowColors(True)
    self.setWordWrap(False)

adapt_sizes()

Source code in prettyqt\widgets\tableview.py

def adapt_sizes(self):
    model = self.model()
    if model is not None and (model.rowCount() * model.columnCount()) < 1000:
        self.resizeColumnsToContents()
    else:
        self.h_header.resize_sections("interactive")

get_grid_style() -> constants.PenStyleStr

Return grid style.

Returns:

Type	Description
constants.PenStyleStr	grid style

Source code in prettyqt\widgets\tableview.py

def get_grid_style(self) -> constants.PenStyleStr:
    """Return grid style.

    Returns:
        grid style
    """
    return constants.PEN_STYLE.inverse[self.gridStyle()]

set_grid_style(style: constants.PenStyleStr)

Set grid style.

Parameters:

Name	Type	Description	Default
style	constants.PenStyleStr	grid style to use	required

Raises:

Type	Description
InvalidParamError	invalid grid style

Source code in prettyqt\widgets\tableview.py

def set_grid_style(self, style: constants.PenStyleStr):
    """Set grid style.

    Args:
        style: grid style to use

    Raises:
        InvalidParamError: invalid grid style
    """
    if style not in constants.PEN_STYLE:
        raise InvalidParamError(style, constants.PEN_STYLE)
    self.setGridStyle(constants.PEN_STYLE[style])

setup_list_style()

Source code in prettyqt\widgets\tableview.py

def setup_list_style(self):
    self.set_selection_behaviour("rows")
    self.h_header.setStretchLastSection(True)
    self.v_header.set_resize_mode("fixed")
    self.v_header.set_default_section_size(28)

sort_by_column(column: int | None, ascending: bool = True)

Source code in prettyqt\widgets\tableview.py

def sort_by_column(self, column: int | None, ascending: bool = True):
    column = -1 if column is None else column
    order = constants.ASCENDING if ascending else constants.DESCENDING
    self.sortByColumn(column, order)

TableWidget

Bases: TableWidgetMixin, QtWidgets.QTableWidget

Source code in prettyqt\widgets\tablewidget.py

class TableWidget(TableWidgetMixin, QtWidgets.QTableWidget):
    pass

TableWidgetItem

Bases: QtWidgets.QTableWidgetItem

Source code in prettyqt\widgets\tablewidgetitem.py

class TableWidgetItem(QtWidgets.QTableWidgetItem):
    def __setitem__(self, index: int, value):
        self.setData(index, value)

    def __getitem__(self, index: int):
        return self.data(index)

    def serialize_fields(self):
        return dict(
            text=self.text(),
            tool_tip=self.toolTip(),
            status_tip=self.statusTip(),
            checkstate=self.get_checkstate(),
            icon=self.get_icon(),
            data=self.data(constants.USER_ROLE),  # type: ignore
        )

    def set_icon(self, icon: datatypes.IconType):
        """Set the icon for the action.

        Args:
            icon: icon to use
        """
        icon = iconprovider.get_icon(icon)
        self.setIcon(icon)

    def set_checkstate(self, state: constants.StateStr):
        """Set checkstate of the checkbox.

        Args:
            state: checkstate to use

        Raises:
            InvalidParamError: invalid checkstate
        """
        if state not in constants.STATE:
            raise InvalidParamError(state, constants.STATE)
        self.setCheckState(constants.STATE[state])

    def get_checkstate(self) -> constants.StateStr:
        """Return checkstate.

        Returns:
            checkstate
        """
        return constants.STATE.inverse[self.checkState()]

    def set_text_alignment(
        self,
        horizontal: constants.HorizontalAlignmentStr | None = None,
        vertical: constants.VerticalAlignmentStr | None = None,
    ):
        """Set text alignment of the checkbox.

        Args:
            horizontal: horizontal text alignment to use
            vertical: vertical text alignment to use

        Raises:
            InvalidParamError: invalid text alignment
        """
        match horizontal, vertical:
            case None, None:
                return
            case None, _:
                flag = constants.V_ALIGNMENT[vertical]
            case _, None:
                flag = constants.H_ALIGNMENT[horizontal]
            case _, _:
                flag = constants.V_ALIGNMENT[vertical] | constants.H_ALIGNMENT[horizontal]
        self.setTextAlignment(flag)

    def get_background(self) -> gui.Brush:
        return gui.Brush(self.background())

    def get_foreground(self) -> gui.Brush:
        return gui.Brush(self.foreground())

    def get_font(self) -> gui.Font:
        return gui.Font(self.font())

    def get_icon(self) -> gui.Icon | None:
        icon = self.icon()
        return None if icon.isNull() else gui.Icon(icon)

    def set_tooltip(
        self,
        tooltip: str | datatypes.PathType,
        size: datatypes.SizeType | None = None,
    ):
        if isinstance(tooltip, os.PathLike):
            path = os.fspath(tooltip)
            if size is None:
                tooltip = f"<img src={path!r}>"
            else:
                if isinstance(size, QtCore.QSize):
                    size = (size.width(), size.height())
                tooltip = f'<img src={path!r} width="{size[0]}" height="{size[1]}">'
        self.setToolTip(tooltip)

__getitem__(index: int)

Source code in prettyqt\widgets\tablewidgetitem.py

def __getitem__(self, index: int):
    return self.data(index)

__setitem__(index: int, value)

Source code in prettyqt\widgets\tablewidgetitem.py

def __setitem__(self, index: int, value):
    self.setData(index, value)

get_background() -> gui.Brush

Source code in prettyqt\widgets\tablewidgetitem.py

def get_background(self) -> gui.Brush:
    return gui.Brush(self.background())

get_checkstate() -> constants.StateStr

Return checkstate.

Returns:

Type	Description
constants.StateStr	checkstate

Source code in prettyqt\widgets\tablewidgetitem.py

def get_checkstate(self) -> constants.StateStr:
    """Return checkstate.

    Returns:
        checkstate
    """
    return constants.STATE.inverse[self.checkState()]

get_font() -> gui.Font

Source code in prettyqt\widgets\tablewidgetitem.py

def get_font(self) -> gui.Font:
    return gui.Font(self.font())

get_foreground() -> gui.Brush

Source code in prettyqt\widgets\tablewidgetitem.py

def get_foreground(self) -> gui.Brush:
    return gui.Brush(self.foreground())

get_icon() -> gui.Icon | None

Source code in prettyqt\widgets\tablewidgetitem.py

def get_icon(self) -> gui.Icon | None:
    icon = self.icon()
    return None if icon.isNull() else gui.Icon(icon)

serialize_fields()

Source code in prettyqt\widgets\tablewidgetitem.py

def serialize_fields(self):
    return dict(
        text=self.text(),
        tool_tip=self.toolTip(),
        status_tip=self.statusTip(),
        checkstate=self.get_checkstate(),
        icon=self.get_icon(),
        data=self.data(constants.USER_ROLE),  # type: ignore
    )

set_checkstate(state: constants.StateStr)

Set checkstate of the checkbox.

Parameters:

Name	Type	Description	Default
state	constants.StateStr	checkstate to use	required

Raises:

Type	Description
InvalidParamError	invalid checkstate

Source code in prettyqt\widgets\tablewidgetitem.py

def set_checkstate(self, state: constants.StateStr):
    """Set checkstate of the checkbox.

    Args:
        state: checkstate to use

    Raises:
        InvalidParamError: invalid checkstate
    """
    if state not in constants.STATE:
        raise InvalidParamError(state, constants.STATE)
    self.setCheckState(constants.STATE[state])

set_icon(icon: datatypes.IconType)

Set the icon for the action.

Parameters:

Name	Type	Description	Default
icon	datatypes.IconType	icon to use	required

Source code in prettyqt\widgets\tablewidgetitem.py

def set_icon(self, icon: datatypes.IconType):
    """Set the icon for the action.

    Args:
        icon: icon to use
    """
    icon = iconprovider.get_icon(icon)
    self.setIcon(icon)

set_text_alignment(horizontal: constants.HorizontalAlignmentStr | None = None, vertical: constants.VerticalAlignmentStr | None = None)

Set text alignment of the checkbox.

Parameters:

Name	Type	Description	Default
horizontal	constants.HorizontalAlignmentStr | None	horizontal text alignment to use	None
vertical	constants.VerticalAlignmentStr | None	vertical text alignment to use	None

Raises:

Type	Description
InvalidParamError	invalid text alignment

Source code in prettyqt\widgets\tablewidgetitem.py

def set_text_alignment(
    self,
    horizontal: constants.HorizontalAlignmentStr | None = None,
    vertical: constants.VerticalAlignmentStr | None = None,
):
    """Set text alignment of the checkbox.

    Args:
        horizontal: horizontal text alignment to use
        vertical: vertical text alignment to use

    Raises:
        InvalidParamError: invalid text alignment
    """
    match horizontal, vertical:
        case None, None:
            return
        case None, _:
            flag = constants.V_ALIGNMENT[vertical]
        case _, None:
            flag = constants.H_ALIGNMENT[horizontal]
        case _, _:
            flag = constants.V_ALIGNMENT[vertical] | constants.H_ALIGNMENT[horizontal]
    self.setTextAlignment(flag)

set_tooltip(tooltip: str | datatypes.PathType, size: datatypes.SizeType | None = None)

Source code in prettyqt\widgets\tablewidgetitem.py

def set_tooltip(
    self,
    tooltip: str | datatypes.PathType,
    size: datatypes.SizeType | None = None,
):
    if isinstance(tooltip, os.PathLike):
        path = os.fspath(tooltip)
        if size is None:
            tooltip = f"<img src={path!r}>"
        else:
            if isinstance(size, QtCore.QSize):
                size = (size.width(), size.height())
            tooltip = f'<img src={path!r} width="{size[0]}" height="{size[1]}">'
    self.setToolTip(tooltip)

TableWidgetSelectionRange

Bases: QtWidgets.QTableWidgetSelectionRange

Source code in prettyqt\widgets\tablewidgetselectionrange.py

class TableWidgetSelectionRange(QtWidgets.QTableWidgetSelectionRange):
    def __repr__(self):
        return get_repr(
            self, self.topRow(), self.leftColumn(), self.bottomRow(), self.rightColumn()
        )

    def __eq__(self, other: object):
        return (
            (
                self.topRow() == other.topRow()
                and self.bottomRow() == other.bottomRow()
                and self.leftColumn() == other.leftColumn()
                and self.rightColumn() == other.rightColumn()
            )
            if isinstance(other, TableWidgetSelectionRange)
            else False
        )

    def __or__(
        self, other: QtWidgets.QTableWidgetSelectionRange
    ) -> TableWidgetSelectionRange:
        return TableWidgetSelectionRange(
            min(self.topRow(), other.topRow()),
            min(self.leftColumn(), other.leftColumn()),
            max(self.bottomRow(), other.bottomRow()),
            max(self.rightColumn(), other.rightColumn()),
        )

    def __and__(
        self, other: QtWidgets.QTableWidgetSelectionRange
    ) -> TableWidgetSelectionRange:
        return (
            TableWidgetSelectionRange()
            if other.topRow() > self.bottomRow()
            and other.bottomRow() < self.topRow()
            and other.leftColumn() > self.rightColumn()
            and other.rightColumn() < self.leftColumn()
            else TableWidgetSelectionRange(
                max(self.topRow(), other.topRow()),
                max(self.leftColumn(), other.leftColumn()),
                min(self.bottomRow(), other.bottomRow()),
                min(self.rightColumn(), other.rightColumn()),
            )
        )

__and__(other: QtWidgets.QTableWidgetSelectionRange) -> TableWidgetSelectionRange

Source code in prettyqt\widgets\tablewidgetselectionrange.py

def __and__(
    self, other: QtWidgets.QTableWidgetSelectionRange
) -> TableWidgetSelectionRange:
    return (
        TableWidgetSelectionRange()
        if other.topRow() > self.bottomRow()
        and other.bottomRow() < self.topRow()
        and other.leftColumn() > self.rightColumn()
        and other.rightColumn() < self.leftColumn()
        else TableWidgetSelectionRange(
            max(self.topRow(), other.topRow()),
            max(self.leftColumn(), other.leftColumn()),
            min(self.bottomRow(), other.bottomRow()),
            min(self.rightColumn(), other.rightColumn()),
        )
    )

__eq__(other: object)

Source code in prettyqt\widgets\tablewidgetselectionrange.py

def __eq__(self, other: object):
    return (
        (
            self.topRow() == other.topRow()
            and self.bottomRow() == other.bottomRow()
            and self.leftColumn() == other.leftColumn()
            and self.rightColumn() == other.rightColumn()
        )
        if isinstance(other, TableWidgetSelectionRange)
        else False
    )

__or__(other: QtWidgets.QTableWidgetSelectionRange) -> TableWidgetSelectionRange

Source code in prettyqt\widgets\tablewidgetselectionrange.py

def __or__(
    self, other: QtWidgets.QTableWidgetSelectionRange
) -> TableWidgetSelectionRange:
    return TableWidgetSelectionRange(
        min(self.topRow(), other.topRow()),
        min(self.leftColumn(), other.leftColumn()),
        max(self.bottomRow(), other.bottomRow()),
        max(self.rightColumn(), other.rightColumn()),
    )

__repr__()

Source code in prettyqt\widgets\tablewidgetselectionrange.py

def __repr__(self):
    return get_repr(
        self, self.topRow(), self.leftColumn(), self.bottomRow(), self.rightColumn()
    )

TapAndHoldGesture

Bases: widgets.GestureMixin, QtWidgets.QTapAndHoldGesture

Source code in prettyqt\widgets\tapandholdgesture.py

class TapAndHoldGesture(widgets.GestureMixin, QtWidgets.QTapAndHoldGesture):
    def get_position(self) -> core.PointF:
        return core.PointF(self.position())

get_position() -> core.PointF

Source code in prettyqt\widgets\tapandholdgesture.py

def get_position(self) -> core.PointF:
    return core.PointF(self.position())

TapGesture

Bases: widgets.GestureMixin, QtWidgets.QTapGesture

Source code in prettyqt\widgets\tapgesture.py

class TapGesture(widgets.GestureMixin, QtWidgets.QTapGesture):
    def get_position(self) -> core.PointF:
        return core.PointF(self.position())

get_position() -> core.PointF

Source code in prettyqt\widgets\tapgesture.py

def get_position(self) -> core.PointF:
    return core.PointF(self.position())

TextBrowser

Bases: widgets.TextEditMixin, QtWidgets.QTextBrowser

Source code in prettyqt\widgets\textbrowser.py

class TextBrowser(widgets.TextEditMixin, QtWidgets.QTextBrowser):
    value_changed = core.Signal(str)

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.setOpenExternalLinks(True)

    # def dragEnterEvent(self, event):
    #     u = event.mimeData().urls()
    #     for url in u:
    #         file_path = os.path.abspath(url.toLocalFile())

    #         ext = file_path.split(".")[-1]
    #         if ext in ["txt", "md", "markdown"]:
    #             event.accept()
    #         else:
    #             event.ignore()

    # def dropEvent(self, event):
    #     event.accept()
    #     self.show_markdown_file(self.filePath)

    def set_markdown_file(self, file_path: datatypes.PathType):
        file_path = pathlib.Path(file_path)
        with file_path.open() as f:
            file_content = f.read()
        self.set_markdown(file_content)

    def set_markdown(self, source: str):
        self.setMarkdown(source)

    def set_rst_file(self, file_path: datatypes.PathType):
        file_path = pathlib.Path(file_path)
        with file_path.open() as f:
            file_content = f.read()
        self.set_rst(file_content)

    def set_rst(self, source: str):
        import docutils.core

        html = docutils.core.publish_string(source, writer_name="html")
        self.setHtml(str(html))

    def get_search_paths(self) -> list[pathlib.Path]:
        return [pathlib.Path(p) for p in self.searchPaths()]

    def set_search_paths(self, paths: list[datatypes.PathType]):
        self.setSearchPaths([os.fspath(p) for p in paths])

value_changed = core.Signal(str) class-attribute

__init__(*args, **kwargs)

Source code in prettyqt\widgets\textbrowser.py

def __init__(self, *args, **kwargs):
    super().__init__(*args, **kwargs)
    self.setOpenExternalLinks(True)

get_search_paths() -> list[pathlib.Path]

Source code in prettyqt\widgets\textbrowser.py

def get_search_paths(self) -> list[pathlib.Path]:
    return [pathlib.Path(p) for p in self.searchPaths()]

set_markdown(source: str)

Source code in prettyqt\widgets\textbrowser.py

def set_markdown(self, source: str):
    self.setMarkdown(source)

set_markdown_file(file_path: datatypes.PathType)

Source code in prettyqt\widgets\textbrowser.py

def set_markdown_file(self, file_path: datatypes.PathType):
    file_path = pathlib.Path(file_path)
    with file_path.open() as f:
        file_content = f.read()
    self.set_markdown(file_content)

set_rst(source: str)

Source code in prettyqt\widgets\textbrowser.py

def set_rst(self, source: str):
    import docutils.core

    html = docutils.core.publish_string(source, writer_name="html")
    self.setHtml(str(html))

set_rst_file(file_path: datatypes.PathType)

Source code in prettyqt\widgets\textbrowser.py

def set_rst_file(self, file_path: datatypes.PathType):
    file_path = pathlib.Path(file_path)
    with file_path.open() as f:
        file_content = f.read()
    self.set_rst(file_content)

set_search_paths(paths: list[datatypes.PathType])

Source code in prettyqt\widgets\textbrowser.py

def set_search_paths(self, paths: list[datatypes.PathType]):
    self.setSearchPaths([os.fspath(p) for p in paths])

TextEdit

Bases: TextEditMixin, QtWidgets.QTextEdit

Source code in prettyqt\widgets\textedit.py

class TextEdit(TextEditMixin, QtWidgets.QTextEdit):
    pass

TextEditMixin

Bases: widgets.AbstractScrollAreaMixin

Source code in prettyqt\widgets\textedit.py

class TextEditMixin(widgets.AbstractScrollAreaMixin):
    value_changed = core.Signal(str)

    def __init__(self, *args, **kwargs) -> None:
        super().__init__(*args, **kwargs)
        self.textChanged.connect(self.on_value_change)

    def __add__(self, other: str) -> TextEdit:
        self.append_text(other)
        return self

    def on_value_change(self) -> None:
        self.value_changed.emit(self.text())

    @contextlib.contextmanager
    def create_cursor(self) -> Iterator[gui.TextCursor]:
        cursor = gui.TextCursor(self.document())
        yield cursor
        self.setTextCursor(cursor)

    def get_text_cursor(self) -> gui.TextCursor:
        return gui.TextCursor(self.textCursor())

    def set_text(self, text: str) -> None:
        self.setPlainText(text)

    def append_text(self, text: str) -> None:
        self.append(text)

    def text(self) -> str:
        return self.toPlainText()

    def select_text(self, start: int, end: int) -> None:
        with self.create_cursor() as c:
            c.select_text(start, end)

    def set_read_only(self, value: bool = True) -> None:
        self.setReadOnly(value)

    def set_text_color(self, color: datatypes.ColorType) -> None:
        color = colors.get_color(color)
        self.setTextColor(color)

    def set_line_wrap_mode(self, mode: LineWrapModeStr):
        """Set line wrap mode.

        Args:
            mode: line wrap mode to use

        Raises:
            InvalidParamError: line wrap mode does not exist
        """
        if mode not in LINE_WRAP_MODE:
            raise InvalidParamError(mode, LINE_WRAP_MODE)
        self.setLineWrapMode(LINE_WRAP_MODE[mode])

    def get_line_wrap_mode(self) -> LineWrapModeStr:
        """Get the current wrap mode.

        Returns:
            Wrap mode
        """
        return LINE_WRAP_MODE.inverse[self.lineWrapMode()]

    def set_auto_formatting(self, mode: AutoFormattingStr):
        """Set auto formatting mode.

        Args:
            mode: auto formatting mode to use

        Raises:
            InvalidParamError: auto formatting mode does not exist
        """
        if mode not in AUTO_FORMATTING:
            raise InvalidParamError(mode, AUTO_FORMATTING)
        self.setAutoFormatting(AUTO_FORMATTING[mode])

    def get_auto_formatting(self) -> AutoFormattingStr:
        """Get the current auto formatting mode.

        Returns:
            Auto formatting mode
        """
        return AUTO_FORMATTING.inverse[self.autoFormatting()]

    def set_word_wrap_mode(self, mode: gui.textoption.WordWrapModeStr):
        """Set word wrap mode.

        Args:
            mode: word wrap mode to use

        Raises:
            InvalidParamError: wrap mode does not exist
        """
        if mode not in gui.textoption.WORD_WRAP_MODE:
            raise InvalidParamError(mode, gui.textoption.WORD_WRAP_MODE)
        self.setWordWrapMode(gui.textoption.WORD_WRAP_MODE[mode])

    def get_word_wrap_mode(self) -> gui.textoption.WordWrapModeStr:
        """Get the current word wrap mode.

        Returns:
            Word wrap mode
        """
        return gui.textoption.WORD_WRAP_MODE.inverse[self.wordWrapMode()]

value_changed = core.Signal(str) class-attribute

__add__(other: str) -> TextEdit

Source code in prettyqt\widgets\textedit.py

def __add__(self, other: str) -> TextEdit:
    self.append_text(other)
    return self

__init__(*args, **kwargs) -> None

Source code in prettyqt\widgets\textedit.py

def __init__(self, *args, **kwargs) -> None:
    super().__init__(*args, **kwargs)
    self.textChanged.connect(self.on_value_change)

append_text(text: str) -> None

Source code in prettyqt\widgets\textedit.py

def append_text(self, text: str) -> None:
    self.append(text)

create_cursor() -> Iterator[gui.TextCursor]

Source code in prettyqt\widgets\textedit.py

@contextlib.contextmanager
def create_cursor(self) -> Iterator[gui.TextCursor]:
    cursor = gui.TextCursor(self.document())
    yield cursor
    self.setTextCursor(cursor)

get_auto_formatting() -> AutoFormattingStr

Get the current auto formatting mode.

Returns:

Type	Description
AutoFormattingStr	Auto formatting mode

Source code in prettyqt\widgets\textedit.py

def get_auto_formatting(self) -> AutoFormattingStr:
    """Get the current auto formatting mode.

    Returns:
        Auto formatting mode
    """
    return AUTO_FORMATTING.inverse[self.autoFormatting()]

get_line_wrap_mode() -> LineWrapModeStr

Get the current wrap mode.

Returns:

Type	Description
LineWrapModeStr	Wrap mode

Source code in prettyqt\widgets\textedit.py

def get_line_wrap_mode(self) -> LineWrapModeStr:
    """Get the current wrap mode.

    Returns:
        Wrap mode
    """
    return LINE_WRAP_MODE.inverse[self.lineWrapMode()]

get_text_cursor() -> gui.TextCursor

Source code in prettyqt\widgets\textedit.py

def get_text_cursor(self) -> gui.TextCursor:
    return gui.TextCursor(self.textCursor())

get_word_wrap_mode() -> gui.textoption.WordWrapModeStr

Get the current word wrap mode.

Returns:

Type	Description
gui.textoption.WordWrapModeStr	Word wrap mode

Source code in prettyqt\widgets\textedit.py

def get_word_wrap_mode(self) -> gui.textoption.WordWrapModeStr:
    """Get the current word wrap mode.

    Returns:
        Word wrap mode
    """
    return gui.textoption.WORD_WRAP_MODE.inverse[self.wordWrapMode()]

on_value_change() -> None

Source code in prettyqt\widgets\textedit.py

def on_value_change(self) -> None:
    self.value_changed.emit(self.text())

select_text(start: int, end: int) -> None

Source code in prettyqt\widgets\textedit.py

def select_text(self, start: int, end: int) -> None:
    with self.create_cursor() as c:
        c.select_text(start, end)

set_auto_formatting(mode: AutoFormattingStr)

Set auto formatting mode.

Parameters:

Name	Type	Description	Default
mode	AutoFormattingStr	auto formatting mode to use	required

Raises:

Type	Description
InvalidParamError	auto formatting mode does not exist

Source code in prettyqt\widgets\textedit.py

def set_auto_formatting(self, mode: AutoFormattingStr):
    """Set auto formatting mode.

    Args:
        mode: auto formatting mode to use

    Raises:
        InvalidParamError: auto formatting mode does not exist
    """
    if mode not in AUTO_FORMATTING:
        raise InvalidParamError(mode, AUTO_FORMATTING)
    self.setAutoFormatting(AUTO_FORMATTING[mode])

set_line_wrap_mode(mode: LineWrapModeStr)

Set line wrap mode.

Parameters:

Name	Type	Description	Default
mode	LineWrapModeStr	line wrap mode to use	required

Raises:

Type	Description
InvalidParamError	line wrap mode does not exist

Source code in prettyqt\widgets\textedit.py

def set_line_wrap_mode(self, mode: LineWrapModeStr):
    """Set line wrap mode.

    Args:
        mode: line wrap mode to use

    Raises:
        InvalidParamError: line wrap mode does not exist
    """
    if mode not in LINE_WRAP_MODE:
        raise InvalidParamError(mode, LINE_WRAP_MODE)
    self.setLineWrapMode(LINE_WRAP_MODE[mode])

set_read_only(value: bool = True) -> None

Source code in prettyqt\widgets\textedit.py

def set_read_only(self, value: bool = True) -> None:
    self.setReadOnly(value)

set_text(text: str) -> None

Source code in prettyqt\widgets\textedit.py

def set_text(self, text: str) -> None:
    self.setPlainText(text)

set_text_color(color: datatypes.ColorType) -> None

Source code in prettyqt\widgets\textedit.py

def set_text_color(self, color: datatypes.ColorType) -> None:
    color = colors.get_color(color)
    self.setTextColor(color)

set_word_wrap_mode(mode: gui.textoption.WordWrapModeStr)

Set word wrap mode.

Parameters:

Name	Type	Description	Default
mode	gui.textoption.WordWrapModeStr	word wrap mode to use	required

Raises:

Type	Description
InvalidParamError	wrap mode does not exist

Source code in prettyqt\widgets\textedit.py

def set_word_wrap_mode(self, mode: gui.textoption.WordWrapModeStr):
    """Set word wrap mode.

    Args:
        mode: word wrap mode to use

    Raises:
        InvalidParamError: wrap mode does not exist
    """
    if mode not in gui.textoption.WORD_WRAP_MODE:
        raise InvalidParamError(mode, gui.textoption.WORD_WRAP_MODE)
    self.setWordWrapMode(gui.textoption.WORD_WRAP_MODE[mode])

text() -> str

Source code in prettyqt\widgets\textedit.py

def text(self) -> str:
    return self.toPlainText()

TimeEdit

Bases: widgets.DateTimeEditMixin, QtWidgets.QTimeEdit

Source code in prettyqt\widgets\timeedit.py

class TimeEdit(widgets.DateTimeEditMixin, QtWidgets.QTimeEdit):
    value_changed = core.Signal(datetime.datetime)

    def set_range(self, lower: datatypes.TimeType, upper: datatypes.TimeType):
        if isinstance(lower, str):
            lower = core.Time.fromString(lower)
        else:
            lower = core.Time(lower)
        if isinstance(upper, str):
            upper = core.Time.fromString(upper)
        else:
            upper = core.Time(upper)
        self.setToolTip(f"{lower.toString()} <= x <= {upper.toString()}")
        self.setTimeRange(lower, upper)  # type: ignore

    def get_value(self) -> datetime.time:
        return self.get_time()

    def set_value(self, value: datatypes.TimeType):
        if isinstance(value, str):
            value = core.Time.fromString(value)
        return self.setTime(value)  # type: ignore

value_changed = core.Signal(datetime.datetime) class-attribute

get_value() -> datetime.time

Source code in prettyqt\widgets\timeedit.py

def get_value(self) -> datetime.time:
    return self.get_time()

set_range(lower: datatypes.TimeType, upper: datatypes.TimeType)

Source code in prettyqt\widgets\timeedit.py

def set_range(self, lower: datatypes.TimeType, upper: datatypes.TimeType):
    if isinstance(lower, str):
        lower = core.Time.fromString(lower)
    else:
        lower = core.Time(lower)
    if isinstance(upper, str):
        upper = core.Time.fromString(upper)
    else:
        upper = core.Time(upper)
    self.setToolTip(f"{lower.toString()} <= x <= {upper.toString()}")
    self.setTimeRange(lower, upper)  # type: ignore

set_value(value: datatypes.TimeType)

Source code in prettyqt\widgets\timeedit.py

def set_value(self, value: datatypes.TimeType):
    if isinstance(value, str):
        value = core.Time.fromString(value)
    return self.setTime(value)  # type: ignore

ToolBar

Bases: ToolBarMixin, QtWidgets.QToolBar

Source code in prettyqt\widgets\toolbar.py

class ToolBar(ToolBarMixin, QtWidgets.QToolBar):
    pass

ToolBox

Bases: widgets.FrameMixin, QtWidgets.QToolBox

Source code in prettyqt\widgets\toolbox.py

class ToolBox(widgets.FrameMixin, QtWidgets.QToolBox):
    def __getitem__(self, index: int | str) -> QtWidgets.QWidget:
        if isinstance(index, int):
            return self.widget(index)
        result = self.find_child(QtWidgets.QWidget, index)
        if result is None:
            raise KeyError("Widget not found")
        return result

    def __delitem__(self, index: int):
        self.removeItem(index)

    # def serialize_fields(self):
    #     children = []
    #     for i, widget in enumerate(self.get_children()):
    #         dct = dict(
    #             widget=widget,
    #             icon=self.item_icon(i),
    #             text=self.itemText(i),
    #             enabled=self.isItemEnabled(i),
    #             tool_tip=self.itemToolTip(i),
    #         )
    #         children.append(dct)
    #     return dict(items=children, current_index=self.currentIndex())

    # def __setstate__(self, state):
    #     for i, item in enumerate(state["items"]):
    #         self.addItem(item["widget"], item["icon"], item["text"])
    #         self.setItemEnabled(i, item["enabled"])
    #         self.setItemToolTip(i, item["tool_tip"])
    #     self.setCurrentIndex(state["current_index"])

    # def __reduce__(self):
    #     return type(self), (), self.__getstate__()

    def __iter__(self) -> Iterator[QtWidgets.QWidget]:
        return iter(self.get_children())

    def __contains__(self, item: QtWidgets.QWidget):
        return self.indexOf(item) >= 0

    def get_children(self) -> list[QtWidgets.QWidget]:
        return [self.widget(i) for i in range(self.count())]

    def add_widget(
        self,
        widget: QtWidgets.QWidget,
        title: str | None = None,
        icon: datatypes.IconType = None,
    ):
        if title is None:
            title = widget.objectName()
        if icon:
            icon = iconprovider.get_icon(icon)
            self.addItem(widget, icon, title)
        else:
            self.addItem(widget, title)

    def item_icon(self, index: int) -> gui.Icon | None:
        icon = self.itemIcon(index)
        return None if icon.isNull() else gui.Icon(icon)

__contains__(item: QtWidgets.QWidget)

Source code in prettyqt\widgets\toolbox.py

def __contains__(self, item: QtWidgets.QWidget):
    return self.indexOf(item) >= 0

__delitem__(index: int)

Source code in prettyqt\widgets\toolbox.py

def __delitem__(self, index: int):
    self.removeItem(index)

__getitem__(index: int | str) -> QtWidgets.QWidget

Source code in prettyqt\widgets\toolbox.py

def __getitem__(self, index: int | str) -> QtWidgets.QWidget:
    if isinstance(index, int):
        return self.widget(index)
    result = self.find_child(QtWidgets.QWidget, index)
    if result is None:
        raise KeyError("Widget not found")
    return result

__iter__() -> Iterator[QtWidgets.QWidget]

Source code in prettyqt\widgets\toolbox.py

def __iter__(self) -> Iterator[QtWidgets.QWidget]:
    return iter(self.get_children())

add_widget(widget: QtWidgets.QWidget, title: str | None = None, icon: datatypes.IconType = None)

Source code in prettyqt\widgets\toolbox.py

def add_widget(
    self,
    widget: QtWidgets.QWidget,
    title: str | None = None,
    icon: datatypes.IconType = None,
):
    if title is None:
        title = widget.objectName()
    if icon:
        icon = iconprovider.get_icon(icon)
        self.addItem(widget, icon, title)
    else:
        self.addItem(widget, title)

get_children() -> list[QtWidgets.QWidget]

Source code in prettyqt\widgets\toolbox.py

def get_children(self) -> list[QtWidgets.QWidget]:
    return [self.widget(i) for i in range(self.count())]

item_icon(index: int) -> gui.Icon | None

Source code in prettyqt\widgets\toolbox.py

def item_icon(self, index: int) -> gui.Icon | None:
    icon = self.itemIcon(index)
    return None if icon.isNull() else gui.Icon(icon)

ToolButton

Bases: widgets.AbstractButtonMixin, QtWidgets.QToolButton

Source code in prettyqt\widgets\toolbutton.py

class ToolButton(widgets.AbstractButtonMixin, QtWidgets.QToolButton):
    def __getitem__(self, item: str) -> QtWidgets.QAction:
        menu = self.menu()
        return menu[item]

    # def set_menu(self, menu: QtWidgets.QMenu):
    #     menu.setParent(self)
    #     self.setMenu(menu)

    @classmethod
    def for_menu(cls, menu: QtWidgets.QMenu, icon: datatypes.IconType = None):
        btn = cls()
        btn.setMenu(menu)
        # btn.set_title(menu.title())
        btn.set_popup_mode("instant")
        btn.set_icon(icon)
        return btn

    def set_default_action(self, action):
        self.setDefaultAction(action)

    def set_popup_mode(self, mode: PopupModeStr):
        """Set the popup mode of the toolbutton.

        Args:
            mode: popup mode to use

        Raises:
            InvalidParamError: invalid popup mode
        """
        if mode not in POPUP_MODE:
            raise InvalidParamError(mode, POPUP_MODE)
        self.setPopupMode(POPUP_MODE[mode])

    def get_popup_mode(self) -> PopupModeStr:
        """Return popup mode.

        Returns:
            popup mode
        """
        return POPUP_MODE.inverse[self.popupMode()]

    def set_arrow_type(self, mode: constants.ArrowTypeStr):
        """Set the arrow type of the toolbutton.

        Args:
            mode: arrow type to use

        Raises:
            InvalidParamError: invalid arrow type
        """
        if mode not in constants.ARROW_TYPE:
            raise InvalidParamError(mode, constants.ARROW_TYPE)
        self.setArrowType(constants.ARROW_TYPE[mode])

    def get_arrow_type(self) -> constants.ArrowTypeStr:
        """Return arrow type.

        Returns:
            arrow type
        """
        return constants.ARROW_TYPE.inverse[self.arrowType()]

    def set_style(self, style: constants.ToolButtonStyleStr):
        """Set the toolbutton style.

        Args:
            style: style to use

        Raises:
            InvalidParamError: invalid style
        """
        if style not in constants.TOOLBUTTON_STYLE:
            raise InvalidParamError(style, constants.TOOLBUTTON_STYLE)
        self.setToolButtonStyle(constants.TOOLBUTTON_STYLE[style])

    def get_style(self) -> constants.ToolButtonStyleStr:
        """Return toolbutton style.

        Returns:
            toolbutton style
        """
        return constants.TOOLBUTTON_STYLE.inverse[self.toolButtonStyle()]

__getitem__(item: str) -> QtWidgets.QAction

Source code in prettyqt\widgets\toolbutton.py

def __getitem__(self, item: str) -> QtWidgets.QAction:
    menu = self.menu()
    return menu[item]

for_menu(menu: QtWidgets.QMenu, icon: datatypes.IconType = None) classmethod

Source code in prettyqt\widgets\toolbutton.py

@classmethod
def for_menu(cls, menu: QtWidgets.QMenu, icon: datatypes.IconType = None):
    btn = cls()
    btn.setMenu(menu)
    # btn.set_title(menu.title())
    btn.set_popup_mode("instant")
    btn.set_icon(icon)
    return btn

get_arrow_type() -> constants.ArrowTypeStr

Return arrow type.

Returns:

Type	Description
constants.ArrowTypeStr	arrow type

Source code in prettyqt\widgets\toolbutton.py

def get_arrow_type(self) -> constants.ArrowTypeStr:
    """Return arrow type.

    Returns:
        arrow type
    """
    return constants.ARROW_TYPE.inverse[self.arrowType()]

get_popup_mode() -> PopupModeStr

Return popup mode.

Returns:

Type	Description
PopupModeStr	popup mode

Source code in prettyqt\widgets\toolbutton.py

def get_popup_mode(self) -> PopupModeStr:
    """Return popup mode.

    Returns:
        popup mode
    """
    return POPUP_MODE.inverse[self.popupMode()]

get_style() -> constants.ToolButtonStyleStr

Return toolbutton style.

Returns:

Type	Description
constants.ToolButtonStyleStr	toolbutton style

Source code in prettyqt\widgets\toolbutton.py

def get_style(self) -> constants.ToolButtonStyleStr:
    """Return toolbutton style.

    Returns:
        toolbutton style
    """
    return constants.TOOLBUTTON_STYLE.inverse[self.toolButtonStyle()]

set_arrow_type(mode: constants.ArrowTypeStr)

Set the arrow type of the toolbutton.

Parameters:

Name	Type	Description	Default
mode	constants.ArrowTypeStr	arrow type to use	required

Raises:

Type	Description
InvalidParamError	invalid arrow type

Source code in prettyqt\widgets\toolbutton.py

def set_arrow_type(self, mode: constants.ArrowTypeStr):
    """Set the arrow type of the toolbutton.

    Args:
        mode: arrow type to use

    Raises:
        InvalidParamError: invalid arrow type
    """
    if mode not in constants.ARROW_TYPE:
        raise InvalidParamError(mode, constants.ARROW_TYPE)
    self.setArrowType(constants.ARROW_TYPE[mode])

set_default_action(action)

Source code in prettyqt\widgets\toolbutton.py

def set_default_action(self, action):
    self.setDefaultAction(action)

set_popup_mode(mode: PopupModeStr)

Set the popup mode of the toolbutton.

Parameters:

Name	Type	Description	Default
mode	PopupModeStr	popup mode to use	required

Raises:

Type	Description
InvalidParamError	invalid popup mode

Source code in prettyqt\widgets\toolbutton.py

def set_popup_mode(self, mode: PopupModeStr):
    """Set the popup mode of the toolbutton.

    Args:
        mode: popup mode to use

    Raises:
        InvalidParamError: invalid popup mode
    """
    if mode not in POPUP_MODE:
        raise InvalidParamError(mode, POPUP_MODE)
    self.setPopupMode(POPUP_MODE[mode])

set_style(style: constants.ToolButtonStyleStr)

Set the toolbutton style.

Parameters:

Name	Type	Description	Default
style	constants.ToolButtonStyleStr	style to use	required

Raises:

Type	Description
InvalidParamError	invalid style

Source code in prettyqt\widgets\toolbutton.py

def set_style(self, style: constants.ToolButtonStyleStr):
    """Set the toolbutton style.

    Args:
        style: style to use

    Raises:
        InvalidParamError: invalid style
    """
    if style not in constants.TOOLBUTTON_STYLE:
        raise InvalidParamError(style, constants.TOOLBUTTON_STYLE)
    self.setToolButtonStyle(constants.TOOLBUTTON_STYLE[style])

ToolTip

Bases: QtWidgets.QToolTip

Source code in prettyqt\widgets\tooltip.py

class ToolTip(QtWidgets.QToolTip):
    @classmethod
    def show_text(
        cls,
        position: datatypes.PointType | None = None,
        text: str = "",
        linebreak_px: int = 400,
    ):
        if position is None:
            position = QtGui.QCursor.pos()
        elif isinstance(position, tuple):
            position = QtCore.QPoint(*position)
        cls.showText(position, f'<div style="max-width: {linebreak_px}px">{text}</div>')

show_text(position: datatypes.PointType | None = None, text: str = '', linebreak_px: int = 400) classmethod

Source code in prettyqt\widgets\tooltip.py

@classmethod
def show_text(
    cls,
    position: datatypes.PointType | None = None,
    text: str = "",
    linebreak_px: int = 400,
):
    if position is None:
        position = QtGui.QCursor.pos()
    elif isinstance(position, tuple):
        position = QtCore.QPoint(*position)
    cls.showText(position, f'<div style="max-width: {linebreak_px}px">{text}</div>')

TreeView

Bases: TreeViewMixin, QtWidgets.QTreeView

Source code in prettyqt\widgets\treeview.py

class TreeView(TreeViewMixin, QtWidgets.QTreeView):
    pass

TreeViewMixin

Bases: widgets.AbstractItemViewMixin

Source code in prettyqt\widgets\treeview.py

class TreeViewMixin(widgets.AbstractItemViewMixin):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        class_name = type(self).__name__
        self.set_id(class_name)
        # visual settings
        self.setAnimated(True)
        self.setRootIsDecorated(False)
        self.setAllColumnsShowFocus(True)
        self.setUniformRowHeights(True)
        self.setAlternatingRowColors(True)
        self.setWordWrap(False)

        # misc
        self.h_header = widgets.HeaderView("horizontal", parent=self)
        self.set_selection_mode("extended")

    def serialize_fields(self):
        return dict(
            all_columns_show_focus=self.allColumnsShowFocus(),
            animated=self.isAnimated(),
            auto_expand_delay=self.autoExpandDelay(),
            expands_on_double_click=self.expandsOnDoubleClick(),
            header_hidden=self.isHeaderHidden(),
            indentation=self.indentation(),
            items_expandable=self.itemsExpandable(),
            root_is_decorated=self.rootIsDecorated(),
            sorting_enabled=self.isSortingEnabled(),
            uniform_row_heights=self.uniformRowHeights(),
            word_wrap=self.wordWrap(),
        )

    @property
    def h_header(self):
        return self.header()

    @h_header.setter
    def h_header(self, header):
        self.setHeader(header)

    def expand_all(self):
        self.expandAll()

    def set_indentation(self, indentation: int):
        self.setIndentation(indentation)

    def setup_list_style(self):
        self.setSelectionBehavior(self.SelectionBehavior.SelectRows)
        self.h_header.setStretchLastSection(True)

    def adapt_sizes(self):
        model = self.model()
        if model is not None and (model.rowCount() * model.columnCount()) < 1000:
            self.h_header.resizeSections(self.h_header.ResizeMode.ResizeToContents)
        else:
            self.h_header.resize_sections("interactive")

    def sort_by_column(self, column: int | None, ascending: bool = True):
        column = -1 if column is None else column
        order = constants.ASCENDING if ascending else constants.DESCENDING
        self.sortByColumn(column, order)

h_header writable property

__init__(*args, **kwargs)

Source code in prettyqt\widgets\treeview.py

def __init__(self, *args, **kwargs):
    super().__init__(*args, **kwargs)
    class_name = type(self).__name__
    self.set_id(class_name)
    # visual settings
    self.setAnimated(True)
    self.setRootIsDecorated(False)
    self.setAllColumnsShowFocus(True)
    self.setUniformRowHeights(True)
    self.setAlternatingRowColors(True)
    self.setWordWrap(False)

    # misc
    self.h_header = widgets.HeaderView("horizontal", parent=self)
    self.set_selection_mode("extended")

adapt_sizes()

Source code in prettyqt\widgets\treeview.py

def adapt_sizes(self):
    model = self.model()
    if model is not None and (model.rowCount() * model.columnCount()) < 1000:
        self.h_header.resizeSections(self.h_header.ResizeMode.ResizeToContents)
    else:
        self.h_header.resize_sections("interactive")

expand_all()

Source code in prettyqt\widgets\treeview.py

def expand_all(self):
    self.expandAll()

serialize_fields()

Source code in prettyqt\widgets\treeview.py

def serialize_fields(self):
    return dict(
        all_columns_show_focus=self.allColumnsShowFocus(),
        animated=self.isAnimated(),
        auto_expand_delay=self.autoExpandDelay(),
        expands_on_double_click=self.expandsOnDoubleClick(),
        header_hidden=self.isHeaderHidden(),
        indentation=self.indentation(),
        items_expandable=self.itemsExpandable(),
        root_is_decorated=self.rootIsDecorated(),
        sorting_enabled=self.isSortingEnabled(),
        uniform_row_heights=self.uniformRowHeights(),
        word_wrap=self.wordWrap(),
    )

set_indentation(indentation: int)

Source code in prettyqt\widgets\treeview.py

def set_indentation(self, indentation: int):
    self.setIndentation(indentation)

setup_list_style()

Source code in prettyqt\widgets\treeview.py

def setup_list_style(self):
    self.setSelectionBehavior(self.SelectionBehavior.SelectRows)
    self.h_header.setStretchLastSection(True)

sort_by_column(column: int | None, ascending: bool = True)

Source code in prettyqt\widgets\treeview.py

def sort_by_column(self, column: int | None, ascending: bool = True):
    column = -1 if column is None else column
    order = constants.ASCENDING if ascending else constants.DESCENDING
    self.sortByColumn(column, order)

TreeWidget

Bases: TreeWidgetMixin, QtWidgets.QTreeWidget

Source code in prettyqt\widgets\treewidget.py

class TreeWidget(TreeWidgetMixin, QtWidgets.QTreeWidget):
    pass

TreeWidgetItem

Bases: serializemixin.SerializeMixin, QtWidgets.QTreeWidgetItem

Source code in prettyqt\widgets\treewidgetitem.py

class TreeWidgetItem(serializemixin.SerializeMixin, QtWidgets.QTreeWidgetItem):
    def __repr__(self):
        return get_repr(self)

    def serialize_fields(self):
        data = [
            self.data(i, constants.USER_ROLE)  # type: ignore
            for i in range(self.columnCount())
        ]
        return dict(
            text=[self.text(i) for i in range(self.columnCount())],
            tool_tip=[self.toolTip(i) for i in range(self.columnCount())],
            status_tip=[self.statusTip(i) for i in range(self.columnCount())],
            checkstate=[self.get_checkstate(i) for i in range(self.columnCount())],
            icon=[self.get_icon(i) for i in range(self.columnCount())],
            data=data,
        )

    def __iter__(self) -> Iterator[QtWidgets.QTreeWidgetItem]:
        return iter(self.child(i) for i in range(self.childCount()))

    def __len__(self):
        return self.childCount()

    def __getitem__(self, index: int) -> QtWidgets.QTreeWidgetItem:
        item = self.child(index)
        if item is None:
            raise KeyError(index)
        return item

    def __delitem__(self, index: int):
        self.takeChild(index)

    def __add__(self, other: QtWidgets.QTreeWidgetItem) -> TreeWidgetItem:
        self.addChild(other)
        return self

    def set_size_hint(self, hint: datatypes.SizeType, column: int = 0):
        if isinstance(hint, tuple):
            hint = QtCore.QSize(*hint)
        self.setSizeHint(column, hint)

    def sort_children(self, column: int, descending: bool = False):
        order = constants.DESCENDING if descending else constants.ASCENDING
        self.sortChildren(column, order)

    def set_icon(self, icon: datatypes.IconType, column: int = 0):
        """Set the icon for the action.

        Args:
            icon: icon to use
            column: column
        """
        icon = iconprovider.get_icon(icon)
        self.setIcon(column, icon)

    def get_background(self, column: int = 0) -> gui.Brush:
        return gui.Brush(self.background(column))

    def get_foreground(self, column: int = 0) -> gui.Brush:
        return gui.Brush(self.foreground(column))

    def get_font(self, column: int = 0) -> gui.Font:
        return gui.Font(self.font(column))

    def get_icon(self, column: int = 0) -> gui.Icon | None:
        icon = self.icon(column)
        return None if icon.isNull() else gui.Icon(icon)

    def set_checkstate(self, state: constants.StateStr, column: int = 0):
        """Set checkstate of the checkbox.

        Args:
            state: checkstate to use
            column: column

        Raises:
            InvalidParamError: invalid checkstate
        """
        if state not in constants.STATE:
            raise InvalidParamError(state, constants.STATE)
        self.setCheckState(column, constants.STATE[state])

    def get_checkstate(self, column: int = 0) -> constants.StateStr:
        """Return checkstate.

        Args:
            column: column

        Returns:
            checkstate
        """
        return constants.STATE.inverse[self.checkState(column)]

    def set_child_indicator_policy(self, policy: ChildIndicatorPolicyStr):
        """Set the child indicator policy.

        Args:
            policy: child indicator policy

        Raises:
            InvalidParamError: policy does not exist
        """
        if policy not in CHILD_INDICATOR_POLICY:
            raise InvalidParamError(policy, CHILD_INDICATOR_POLICY)
        self.setChildIndicatorPolicy(CHILD_INDICATOR_POLICY[policy])

    def get_child_indicator_policy(self) -> ChildIndicatorPolicyStr:
        """Return current child indicator policy.

        Returns:
            child indicator policy
        """
        return CHILD_INDICATOR_POLICY.inverse[self.childIndicatorPolicy()]

__add__(other: QtWidgets.QTreeWidgetItem) -> TreeWidgetItem

Source code in prettyqt\widgets\treewidgetitem.py

def __add__(self, other: QtWidgets.QTreeWidgetItem) -> TreeWidgetItem:
    self.addChild(other)
    return self

__delitem__(index: int)

Source code in prettyqt\widgets\treewidgetitem.py

def __delitem__(self, index: int):
    self.takeChild(index)

__getitem__(index: int) -> QtWidgets.QTreeWidgetItem

Source code in prettyqt\widgets\treewidgetitem.py

def __getitem__(self, index: int) -> QtWidgets.QTreeWidgetItem:
    item = self.child(index)
    if item is None:
        raise KeyError(index)
    return item

__iter__() -> Iterator[QtWidgets.QTreeWidgetItem]

Source code in prettyqt\widgets\treewidgetitem.py

def __iter__(self) -> Iterator[QtWidgets.QTreeWidgetItem]:
    return iter(self.child(i) for i in range(self.childCount()))

__len__()

Source code in prettyqt\widgets\treewidgetitem.py

def __len__(self):
    return self.childCount()

__repr__()

Source code in prettyqt\widgets\treewidgetitem.py

def __repr__(self):
    return get_repr(self)

get_background(column: int = 0) -> gui.Brush

Source code in prettyqt\widgets\treewidgetitem.py

def get_background(self, column: int = 0) -> gui.Brush:
    return gui.Brush(self.background(column))

get_checkstate(column: int = 0) -> constants.StateStr

Return checkstate.

Parameters:

Name	Type	Description	Default
column	int	column	0

Returns:

Type	Description
constants.StateStr	checkstate

Source code in prettyqt\widgets\treewidgetitem.py

def get_checkstate(self, column: int = 0) -> constants.StateStr:
    """Return checkstate.

    Args:
        column: column

    Returns:
        checkstate
    """
    return constants.STATE.inverse[self.checkState(column)]

get_child_indicator_policy() -> ChildIndicatorPolicyStr

Return current child indicator policy.

Returns:

Type	Description
ChildIndicatorPolicyStr	child indicator policy

Source code in prettyqt\widgets\treewidgetitem.py

def get_child_indicator_policy(self) -> ChildIndicatorPolicyStr:
    """Return current child indicator policy.

    Returns:
        child indicator policy
    """
    return CHILD_INDICATOR_POLICY.inverse[self.childIndicatorPolicy()]

get_font(column: int = 0) -> gui.Font

Source code in prettyqt\widgets\treewidgetitem.py

def get_font(self, column: int = 0) -> gui.Font:
    return gui.Font(self.font(column))

get_foreground(column: int = 0) -> gui.Brush

Source code in prettyqt\widgets\treewidgetitem.py

def get_foreground(self, column: int = 0) -> gui.Brush:
    return gui.Brush(self.foreground(column))

get_icon(column: int = 0) -> gui.Icon | None

Source code in prettyqt\widgets\treewidgetitem.py

def get_icon(self, column: int = 0) -> gui.Icon | None:
    icon = self.icon(column)
    return None if icon.isNull() else gui.Icon(icon)

serialize_fields()

Source code in prettyqt\widgets\treewidgetitem.py

def serialize_fields(self):
    data = [
        self.data(i, constants.USER_ROLE)  # type: ignore
        for i in range(self.columnCount())
    ]
    return dict(
        text=[self.text(i) for i in range(self.columnCount())],
        tool_tip=[self.toolTip(i) for i in range(self.columnCount())],
        status_tip=[self.statusTip(i) for i in range(self.columnCount())],
        checkstate=[self.get_checkstate(i) for i in range(self.columnCount())],
        icon=[self.get_icon(i) for i in range(self.columnCount())],
        data=data,
    )

set_checkstate(state: constants.StateStr, column: int = 0)

Set checkstate of the checkbox.

Parameters:

Name	Type	Description	Default
state	constants.StateStr	checkstate to use	required
column	int	column	0

Raises:

Type	Description
InvalidParamError	invalid checkstate

Source code in prettyqt\widgets\treewidgetitem.py

def set_checkstate(self, state: constants.StateStr, column: int = 0):
    """Set checkstate of the checkbox.

    Args:
        state: checkstate to use
        column: column

    Raises:
        InvalidParamError: invalid checkstate
    """
    if state not in constants.STATE:
        raise InvalidParamError(state, constants.STATE)
    self.setCheckState(column, constants.STATE[state])

set_child_indicator_policy(policy: ChildIndicatorPolicyStr)

Set the child indicator policy.

Parameters:

Name	Type	Description	Default
policy	ChildIndicatorPolicyStr	child indicator policy	required

Raises:

Type	Description
InvalidParamError	policy does not exist

Source code in prettyqt\widgets\treewidgetitem.py

def set_child_indicator_policy(self, policy: ChildIndicatorPolicyStr):
    """Set the child indicator policy.

    Args:
        policy: child indicator policy

    Raises:
        InvalidParamError: policy does not exist
    """
    if policy not in CHILD_INDICATOR_POLICY:
        raise InvalidParamError(policy, CHILD_INDICATOR_POLICY)
    self.setChildIndicatorPolicy(CHILD_INDICATOR_POLICY[policy])

set_icon(icon: datatypes.IconType, column: int = 0)

Set the icon for the action.

Parameters:

Name	Type	Description	Default
icon	datatypes.IconType	icon to use	required
column	int	column	0

Source code in prettyqt\widgets\treewidgetitem.py

def set_icon(self, icon: datatypes.IconType, column: int = 0):
    """Set the icon for the action.

    Args:
        icon: icon to use
        column: column
    """
    icon = iconprovider.get_icon(icon)
    self.setIcon(column, icon)

set_size_hint(hint: datatypes.SizeType, column: int = 0)

Source code in prettyqt\widgets\treewidgetitem.py

def set_size_hint(self, hint: datatypes.SizeType, column: int = 0):
    if isinstance(hint, tuple):
        hint = QtCore.QSize(*hint)
    self.setSizeHint(column, hint)

sort_children(column: int, descending: bool = False)

Source code in prettyqt\widgets\treewidgetitem.py

def sort_children(self, column: int, descending: bool = False):
    order = constants.DESCENDING if descending else constants.ASCENDING
    self.sortChildren(column, order)

TreeWidgetItemIterator

Bases: QtWidgets.QTreeWidgetItemIterator

Source code in prettyqt\widgets\treewidgetitemiterator.py

class TreeWidgetItemIterator(QtWidgets.QTreeWidgetItemIterator):
    def __init__(
        self,
        other: (
            QtWidgets.QTreeWidget
            | QtWidgets.QTreeWidgetItem
            | QtWidgets.QTreeWidgetItemIterator
        ),
        flags: QtWidgets.QTreeWidgetItemIterator.IteratorFlag | None = None,
        hidden: bool | None = None,
        selected: bool | None = None,
        selectable: bool | None = None,
        draggable: bool | None = None,
        droppable: bool | None = None,
        has_children: bool | None = None,
        checked: bool | None = None,
        enabled: bool | None = None,
        editable: bool | None = None,
        user_flag: bool = False,
    ):
        if isinstance(other, QtWidgets.QTreeWidgetItemIterator):
            super().__init__(other)
        else:
            if flags is None:
                flags = mod.IteratorFlag.All  # type: ignore
            if hidden is True:
                flags |= mod.IteratorFlag.Hidden  # type: ignore
            elif hidden is False:
                flags |= mod.IteratorFlag.NotHidden  # type: ignore
            if selected is True:
                flags |= mod.IteratorFlag.Selected  # type: ignore
            elif selected is False:
                flags |= mod.IteratorFlag.Unselected  # type: ignore
            if selectable is True:
                flags |= mod.IteratorFlag.Selectable  # type: ignore
            elif selectable is False:
                flags |= mod.IteratorFlag.NotSelectable  # type: ignore
            if draggable is True:
                flags |= mod.IteratorFlag.DragEnabled  # type: ignore
            elif draggable is False:
                flags |= mod.IteratorFlag.DragDisabled  # type: ignore
            if droppable is True:
                flags |= mod.IteratorFlag.DropEnabled  # type: ignore
            elif droppable is False:
                flags |= mod.IteratorFlag.DropDisabled  # type: ignore
            if has_children is True:
                flags |= mod.IteratorFlag.HasChildren  # type: ignore
            elif has_children is False:
                flags |= mod.IteratorFlag.NoChildren  # type: ignore
            if checked is True:
                flags |= mod.IteratorFlag.Checked  # type: ignore
            elif checked is False:
                flags |= mod.IteratorFlag.NotChecked  # type: ignore
            if enabled is True:
                flags |= mod.IteratorFlag.Enabled  # type: ignore
            elif enabled is False:
                flags |= mod.IteratorFlag.Disabled  # type: ignore
            if editable is True:
                flags |= mod.IteratorFlag.Editable  # type: ignore
            elif editable is False:
                flags |= mod.IteratorFlag.NotEditable  # type: ignore
            if user_flag:
                flags |= mod.IteratorFlag.UserFlag  # type: ignore
            super().__init__(other, flags)  # type: ignore

__init__(other: QtWidgets.QTreeWidget | QtWidgets.QTreeWidgetItem | QtWidgets.QTreeWidgetItemIterator, flags: QtWidgets.QTreeWidgetItemIterator.IteratorFlag | None = None, hidden: bool | None = None, selected: bool | None = None, selectable: bool | None = None, draggable: bool | None = None, droppable: bool | None = None, has_children: bool | None = None, checked: bool | None = None, enabled: bool | None = None, editable: bool | None = None, user_flag: bool = False)

Source code in prettyqt\widgets\treewidgetitemiterator.py

def __init__(
    self,
    other: (
        QtWidgets.QTreeWidget
        | QtWidgets.QTreeWidgetItem
        | QtWidgets.QTreeWidgetItemIterator
    ),
    flags: QtWidgets.QTreeWidgetItemIterator.IteratorFlag | None = None,
    hidden: bool | None = None,
    selected: bool | None = None,
    selectable: bool | None = None,
    draggable: bool | None = None,
    droppable: bool | None = None,
    has_children: bool | None = None,
    checked: bool | None = None,
    enabled: bool | None = None,
    editable: bool | None = None,
    user_flag: bool = False,
):
    if isinstance(other, QtWidgets.QTreeWidgetItemIterator):
        super().__init__(other)
    else:
        if flags is None:
            flags = mod.IteratorFlag.All  # type: ignore
        if hidden is True:
            flags |= mod.IteratorFlag.Hidden  # type: ignore
        elif hidden is False:
            flags |= mod.IteratorFlag.NotHidden  # type: ignore
        if selected is True:
            flags |= mod.IteratorFlag.Selected  # type: ignore
        elif selected is False:
            flags |= mod.IteratorFlag.Unselected  # type: ignore
        if selectable is True:
            flags |= mod.IteratorFlag.Selectable  # type: ignore
        elif selectable is False:
            flags |= mod.IteratorFlag.NotSelectable  # type: ignore
        if draggable is True:
            flags |= mod.IteratorFlag.DragEnabled  # type: ignore
        elif draggable is False:
            flags |= mod.IteratorFlag.DragDisabled  # type: ignore
        if droppable is True:
            flags |= mod.IteratorFlag.DropEnabled  # type: ignore
        elif droppable is False:
            flags |= mod.IteratorFlag.DropDisabled  # type: ignore
        if has_children is True:
            flags |= mod.IteratorFlag.HasChildren  # type: ignore
        elif has_children is False:
            flags |= mod.IteratorFlag.NoChildren  # type: ignore
        if checked is True:
            flags |= mod.IteratorFlag.Checked  # type: ignore
        elif checked is False:
            flags |= mod.IteratorFlag.NotChecked  # type: ignore
        if enabled is True:
            flags |= mod.IteratorFlag.Enabled  # type: ignore
        elif enabled is False:
            flags |= mod.IteratorFlag.Disabled  # type: ignore
        if editable is True:
            flags |= mod.IteratorFlag.Editable  # type: ignore
        elif editable is False:
            flags |= mod.IteratorFlag.NotEditable  # type: ignore
        if user_flag:
            flags |= mod.IteratorFlag.UserFlag  # type: ignore
        super().__init__(other, flags)  # type: ignore

UndoView

Bases: widgets.ListViewMixin, QtWidgets.QUndoView

Source code in prettyqt\widgets\undoview.py

class UndoView(widgets.ListViewMixin, QtWidgets.QUndoView):
    def __getitem__(self, index: int) -> QtGui.QUndoCommand:
        return self.stack().command(index)

    def set_clean_icon(self, icon: datatypes.IconType):
        """Set the icon for the clean button.

        Args:
            icon: icon to use
        """
        icon = iconprovider.get_icon(icon)
        self.setCleanIcon(icon)

    def set_value(self, value: QtGui.QUndoGroup | QtGui.QUndoStack):
        if isinstance(value, QtGui.QUndoGroup):
            self.setGroup(value)
        else:
            self.setStack(value)

__getitem__(index: int) -> QtGui.QUndoCommand

Source code in prettyqt\widgets\undoview.py

def __getitem__(self, index: int) -> QtGui.QUndoCommand:
    return self.stack().command(index)

set_clean_icon(icon: datatypes.IconType)

Set the icon for the clean button.

Parameters:

Name	Type	Description	Default
icon	datatypes.IconType	icon to use	required

Source code in prettyqt\widgets\undoview.py

def set_clean_icon(self, icon: datatypes.IconType):
    """Set the icon for the clean button.

    Args:
        icon: icon to use
    """
    icon = iconprovider.get_icon(icon)
    self.setCleanIcon(icon)

set_value(value: QtGui.QUndoGroup | QtGui.QUndoStack)

Source code in prettyqt\widgets\undoview.py

def set_value(self, value: QtGui.QUndoGroup | QtGui.QUndoStack):
    if isinstance(value, QtGui.QUndoGroup):
        self.setGroup(value)
    else:
        self.setStack(value)

WhatsThis

Bases: QtWidgets.QWhatsThis

Source code in prettyqt\widgets\whatsthis.py

class WhatsThis(QtWidgets.QWhatsThis):
    @classmethod
    @contextlib.contextmanager
    def enter_mode(cls):
        cls.enterWhatsThisMode()
        yield cls
        cls.leaveWhatsThisMode()

enter_mode() classmethod

Source code in prettyqt\widgets\whatsthis.py

@classmethod
@contextlib.contextmanager
def enter_mode(cls):
    cls.enterWhatsThisMode()
    yield cls
    cls.leaveWhatsThisMode()

Widget

Bases: WidgetMixin, prettyprinter.PrettyPrinter, QtWidgets.QWidget

Source code in prettyqt\widgets\widget.py

class Widget(WidgetMixin, prettyprinter.PrettyPrinter, QtWidgets.QWidget):
    pass

WidgetAction

Bases: widgets.ActionMixin, QtWidgets.QWidgetAction

Source code in prettyqt\widgets\widgetaction.py

class WidgetAction(widgets.ActionMixin, QtWidgets.QWidgetAction):
    def __init__(self, parent: QtCore.QObject | None = None):
        super().__init__(parent)  # type: ignore
        self._menu = None  # bc of PySide inheritance also defined here

__init__(parent: QtCore.QObject | None = None)

Source code in prettyqt\widgets\widgetaction.py

def __init__(self, parent: QtCore.QObject | None = None):
    super().__init__(parent)  # type: ignore
    self._menu = None  # bc of PySide inheritance also defined here

WidgetItem

Bases: widgets.LayoutItemMixin, QtWidgets.QWidgetItem

Source code in prettyqt\widgets\widgetitem.py

class WidgetItem(widgets.LayoutItemMixin, QtWidgets.QWidgetItem):
    pass

WidgetMixin

Bases: core.ObjectMixin

Source code in prettyqt\widgets\widget.py

class WidgetMixin(core.ObjectMixin):
    box: QtWidgets.QLayout

    def __repr__(self) -> str:
        return get_repr(self)

    def resize(self, *size) -> None:
        if isinstance(size[0], tuple):
            super().resize(*size[0])
        else:
            super().resize(*size)

    def insertAction(
        self, position_or_action: int | QtWidgets.QAction, action: QtWidgets.QAction
    ):
        """Extend insertAction to also allow int index."""
        if isinstance(position_or_action, int):
            position_or_action = self.actions()[position_or_action]
        super().insertAction(position_or_action, action)

    def toggle_fullscreen(self):
        """Toggle between fullscreen and regular size."""
        if self.isFullScreen():
            self.showNormal()
        else:
            self.showFullScreen()

    def toggle_maximized(self):
        """Toggle between maximized and regular size."""
        if self.isMaximized():
            self.showNormal()
        else:
            self.showMaximized()

    def raise_to_top(self):
        if sys.platform.startswith("win"):
            import win32con
            from win32gui import SetWindowPos

            # set to always-on-top and disable it again. that way windows stays in front
            flag = win32con.SWP_NOMOVE | win32con.SWP_NOSIZE | win32con.SWP_SHOWWINDOW
            win_id = self.winId()
            SetWindowPos(win_id, win32con.HWND_TOPMOST, 0, 0, 0, 0, flag)
            SetWindowPos(win_id, win32con.HWND_NOTOPMOST, 0, 0, 0, 0, flag)
        # state = (self.windowState() & ~Qt.WindowMinimized) | Qt.WindowActive
        # self.setWindowState(state)
        self.raise_()
        self.show()
        self.activateWindow()

    def set_icon(self, icon: datatypes.IconType) -> None:
        """Set the window icon.

        Args:
            icon: icon to use
        """
        icon = iconprovider.get_icon(icon, color=colors.WINDOW_ICON_COLOR)
        self.setWindowIcon(icon)

    def get_icon(self) -> gui.Icon | None:
        icon = self.windowIcon()
        return None if icon.isNull() else gui.Icon(icon)

    @functools.singledispatchmethod
    def set_min_size(self, size: QtCore.QSize | tuple[int | None, int | None]) -> None:
        if isinstance(size, tuple):
            x = 0 if size[0] is None else size[0]
            y = 0 if size[1] is None else size[1]
            self.setMinimumSize(x, y)
        else:
            self.setMinimumSize(size)

    @set_min_size.register
    def _(self, x: int, y: int | None):
        self.set_min_size((x, y))

    @set_min_size.register  # these can be merged when min py version is 3.11
    def _(self, x: None, y: int | None):
        self.set_min_size((x, y))

    @functools.singledispatchmethod
    def set_max_size(self, size: QtCore.QSize | tuple[int | None, int | None]) -> None:
        if isinstance(size, tuple):
            x = QWIDGETSIZE_MAX if size[0] is None else size[0]
            y = QWIDGETSIZE_MAX if size[1] is None else size[1]
            self.setMaximumSize(x, y)
        else:
            self.setMaximumSize(size)

    @set_max_size.register
    def _(self, x: int, y: int | None):
        self.set_max_size((x, y))

    @set_max_size.register  # these can be merged when min py version is 3.11
    def _(self, x: None, y: int | None):
        self.set_max_size((x, y))

    def set_min_width(self, width: int | None) -> None:
        if width is None:
            width = 0
        self.setMinimumWidth(width)

    def set_max_width(self, width: int | None) -> None:
        if width is None:
            width = QWIDGETSIZE_MAX
        self.setMaximumWidth(width)

    def set_min_height(self, height: int | None) -> None:
        if height is None:
            height = 0
        self.setMinimumHeight(height)

    def set_max_height(self, height: int | None) -> None:
        if height is None:
            height = QWIDGETSIZE_MAX
        self.setMaximumHeight(height)

    def set_enabled(self, enabled: bool = True) -> None:
        self.setEnabled(enabled)

    def set_disabled(self) -> None:
        self.setEnabled(False)

    def set_title(self, title: str) -> None:
        self.setWindowTitle(title)

    def get_title(self) -> str:
        return self.windowTitle()

    def set_tooltip(
        self,
        tooltip: str | datatypes.PathType,
        size: datatypes.SizeType | None = None,
    ):
        if isinstance(tooltip, os.PathLike):
            path = os.fspath(tooltip)
            if size is None:
                tooltip = f"<img src={path!r}>"
            else:
                if isinstance(size, QtCore.QSize):
                    size = (size.width(), size.height())
                tooltip = f'<img src={path!r} width="{size[0]}" height="{size[1]}">'
        self.setToolTip(tooltip)

    def set_font(
        self,
        font_name: str | None = None,
        font_size: int | None = None,
        weight: int | None = None,
        italic: bool = False,
    ) -> gui.Font:
        if font_size is None:
            font_size = -1
        if weight is None:
            weight = -1
        if font_name is None:
            font_name = self.font().family()
        font = gui.Font(font_name, font_size, weight, italic)
        self.setFont(font)
        return font

    def get_font(self) -> gui.Font:
        return gui.Font(self.font())

    def get_foreground_role(self) -> gui.palette.RoleStr:
        return gui.palette.ROLE.inverse[self.foregroundRole()]

    def set_foreground_role(self, role: gui.palette.RoleStr):
        if role not in gui.palette.ROLE:
            raise InvalidParamError(role, gui.palette.ROLE)
        self.setForegroundRole(gui.palette.ROLE[role])

    def get_background_role(self) -> gui.palette.RoleStr:
        return gui.palette.ROLE.inverse[self.backgroundRole()]

    def set_background_role(self, role: gui.palette.RoleStr):
        if role not in gui.palette.ROLE:
            raise InvalidParamError(role, gui.palette.ROLE)
        self.setBackgroundRole(gui.palette.ROLE[role])

    def set_window_flags(self, *flags: constants.WindowFlagStr, append: bool = False):
        for flag in flags:
            if flag not in constants.WINDOW_FLAGS:
                raise InvalidParamError(flag, constants.WINDOW_FLAGS)
        result = helpers.merge_flags(flags, constants.WINDOW_FLAGS)
        if append:
            result = result | self.windowFlags()
        self.setWindowFlags(result)

    def set_flags(
        self,
        minimize: bool | None = None,
        maximize: bool | None = None,
        close: bool | None = None,
        stay_on_top: bool | None = None,
        frameless: bool | None = None,
        window: bool | None = None,
        dialog: bool | None = None,
        tooltip: bool | None = None,
        tool: bool | None = None,
        customize: bool | None = None,
        window_title: bool | None = None,
    ) -> None:
        flags = {
            minimize: QtCore.Qt.WindowType.WindowMinimizeButtonHint,
            maximize: QtCore.Qt.WindowType.WindowMaximizeButtonHint,
            close: QtCore.Qt.WindowType.WindowCloseButtonHint,
            stay_on_top: QtCore.Qt.WindowType.WindowStaysOnTopHint,
            frameless: QtCore.Qt.WindowType.FramelessWindowHint,
            window: QtCore.Qt.WindowType.Window,
            dialog: QtCore.Qt.WindowType.Dialog,
            tooltip: QtCore.Qt.WindowType.ToolTip,
            tool: QtCore.Qt.WindowType.Tool,
            customize: QtCore.Qt.WindowType.CustomizeWindowHint,
            window_title: QtCore.Qt.WindowType.WindowTitleHint,
        }
        for k, v in flags.items():
            if k is not None:
                self.setWindowFlag(v, k)

    def set_attribute(
        self, attribute: constants.WidgetAttributeStr, state: bool = True
    ) -> None:
        if attribute not in constants.WIDGET_ATTRIBUTE:
            raise InvalidParamError(attribute, constants.WIDGET_ATTRIBUTE)
        self.setAttribute(constants.WIDGET_ATTRIBUTE[attribute], state)

    def set_attributes(self, **kwargs: bool) -> None:
        for attr, state in kwargs.items():
            if attr not in constants.WIDGET_ATTRIBUTE:
                raise InvalidParamError(attr, constants.WIDGET_ATTRIBUTE)
            self.setAttribute(constants.WIDGET_ATTRIBUTE[attr], state)  # type: ignore

    def set_modality(self, modality: constants.ModalityStr) -> None:
        """Set modality for the dialog.

        Args:
            modality: modality for the main window

        Raises:
            InvalidParamError: modality type does not exist
        """
        if modality not in constants.MODALITY:
            raise InvalidParamError(modality, constants.MODALITY)
        self.setWindowModality(constants.MODALITY[modality])

    def get_modality(self) -> constants.ModalityStr:
        """Get the current modality modes as a string.

        Returns:
            modality mode
        """
        return constants.MODALITY.inverse[self.windowModality()]

    def set_size_policy(
        self,
        horizontal: widgets.sizepolicy.SizePolicyStr | None = None,
        vertical: widgets.sizepolicy.SizePolicyStr | None = None,
    ) -> None:
        """Set the sizes policy.

        Args:
            horizontal: horizontal size policy
            vertical: vertical size policy
        """
        sp = self.get_size_policy()
        if horizontal is not None:
            sp.set_horizontal_policy(horizontal)
        if vertical is not None:
            sp.set_vertical_policy(vertical)
        self.setSizePolicy(sp)

    def get_size_policy(self) -> widgets.SizePolicy:
        qpol = self.sizePolicy()
        if isinstance(qpol, widgets.SizePolicy):
            return qpol
        return widgets.SizePolicy.clone(qpol)

    def get_palette(self) -> gui.Palette:
        return gui.Palette(self.palette())

    def set_background_color(self, color: datatypes.ColorType) -> None:
        col_str = "" if color is None else colors.get_color(color).name()
        with self.edit_stylesheet() as ss:
            ss.backgroundColor.setValue(col_str)

    @contextlib.contextmanager
    def grab_mouse_events(
        self, cursor_shape: constants.CursorShapeStr | None = None
    ) -> Iterator[None]:
        if cursor_shape is not None:
            self.grabMouse(constants.CURSOR_SHAPE[cursor_shape])
        else:
            self.grabMouse()
        yield None
        self.releaseMouse()

    @contextlib.contextmanager
    def grab_keyboard_events(self) -> Iterator[None]:
        self.grabKeyboard()
        yield None
        self.releaseKeyboard()

    @contextlib.contextmanager
    def updates_off(self) -> Iterator[None]:
        updates = self.updatesEnabled()
        self.setUpdatesEnabled(False)
        yield None
        self.setUpdatesEnabled(updates)

    @contextlib.contextmanager
    def edit_stylesheet(self) -> Iterator[qstylizer.style.StyleSheet]:
        ss = self.get_stylesheet()
        yield ss
        self.set_stylesheet(ss)

    def set_stylesheet(
        self, ss: None | str | qstylizer.style.StyleSheet | datatypes.PathType
    ):
        match ss:
            case None:
                ss = ""
            case os.PathLike():
                ss = pathlib.Path(ss).read_text()
            case qstylizer.style.StyleSheet():
                ss = str(ss)
        self.setStyleSheet(ss)

    def get_stylesheet(self) -> qstylizer.style.StyleSheet:
        try:
            return qstylizer.parser.parse(self.styleSheet())
        except ValueError:
            return qstylizer.style.StyleSheet()

    @contextlib.contextmanager
    def edit_palette(self) -> Iterator[gui.Palette]:
        palette = gui.Palette(self.palette())
        yield palette
        self.setPalette(palette)

    @contextlib.contextmanager
    def edit_font(self) -> Iterator[gui.Font]:
        font = gui.Font(self.font())
        yield font
        self.setFont(font)

    @deprecated(reason="This context manager is deprecated, use edit_font instead.")
    @contextlib.contextmanager
    def current_font(self) -> Iterator[gui.Font]:
        with self.edit_font() as font:
            yield font

    @deprecated(reason="This method is deprecated, use set_context_menu_policy instead.")
    def set_contextmenu_policy(self, policy: constants.ContextPolicyStr) -> None:
        return self.set_context_menu_policy(policy)

    def set_context_menu_policy(self, policy: constants.ContextPolicyStr) -> None:
        """Set contextmenu policy for given item view.

        Args:
            policy: contextmenu policy to use

        Raises:
            InvalidParamError: policy does not exist
        """
        if policy not in constants.CONTEXT_POLICY:
            raise InvalidParamError(policy, constants.CONTEXT_POLICY)
        self.setContextMenuPolicy(constants.CONTEXT_POLICY[policy])

    @deprecated(reason="This method is deprecated, use get_context_menu_policy instead.")
    def get_contextmenu_policy(self) -> constants.ContextPolicyStr:
        """Return current contextmenu policy.

        Returns:
            contextmenu policy
        """
        return self.get_context_menu_policy()

    def get_context_menu_policy(self) -> constants.ContextPolicyStr:
        """Return current contextmenu policy.

        Returns:
            contextmenu policy
        """
        return constants.CONTEXT_POLICY.inverse[self.contextMenuPolicy()]

    def set_window_state(self, policy: constants.WindowStateStr) -> None:
        """Set window state for given item view.

        Args:
            policy: window state to use

        Raises:
            InvalidParamError: policy does not exist
        """
        if policy not in constants.WINDOW_STATES:
            raise InvalidParamError(policy, constants.WINDOW_STATES)
        self.setWindowState(constants.WINDOW_STATES[policy])

    def get_window_state(self) -> constants.WindowStateStr:
        """Return current window state.

        Returns:
            window state
        """
        return constants.WINDOW_STATES.inverse[self.windowState()]

    def set_custom_menu(self, method: Callable) -> None:
        self.set_context_menu_policy("custom")
        self.customContextMenuRequested.connect(method)

    def set_layout(
        self,
        layout: LayoutStr | QtWidgets.QLayout | None,
        margin: int | None = None,
        spacing: int | None = None,
    ):
        if layout is None:
            return
        match layout:
            case "horizontal" | "vertical":
                self.box = widgets.BoxLayout(layout)
            case "grid":
                self.box = widgets.GridLayout()
            case "form":
                self.box = widgets.FormLayout()
            case "stacked":
                self.box = widgets.StackedLayout()
            case "flow":
                from prettyqt import custom_widgets

                self.box = custom_widgets.FlowLayout()
            case QtWidgets.QLayout():
                self.box = layout
            case _:
                raise ValueError("Invalid Layout")
        self.setLayout(self.box)
        if margin is not None:
            self.box.set_margin(margin)
        if spacing is not None:
            self.box.setSpacing(spacing)

    def center(self, screen: int = 0) -> None:
        qr = self.frameGeometry()
        cp = gui.GuiApplication.screens()[screen].geometry().center()
        qr.moveCenter(cp)
        self.move(qr.topLeft())

    def set_cursor(self, cursor: constants.CursorShapeStr | QtGui.QCursor) -> None:
        if isinstance(cursor, QtGui.QCursor):
            curs = cursor
        elif cursor in constants.CURSOR_SHAPE:
            curs = gui.Cursor(constants.CURSOR_SHAPE[cursor])
        else:
            raise InvalidParamError(cursor, constants.CURSOR_SHAPE)
        self.setCursor(curs)

    def set_focus_policy(self, policy: constants.FocusPolicyStr) -> None:
        """Set the way the widget accepts keyboard focus.

        Args:
            policy (str): Focus policy

        Raises:
            InvalidParamError: Description
        """
        if policy not in constants.FOCUS_POLICY:
            raise InvalidParamError(policy, constants.FOCUS_POLICY)
        self.setFocusPolicy(constants.FOCUS_POLICY[policy])

    def get_focus_policy(self) -> constants.FocusPolicyStr:
        """Return waay the widget accepts keyboard focus.

        Returns:
            str: Focus policy
        """
        return constants.FOCUS_POLICY.inverse[self.focusPolicy()]

    def set_font_size(self, size: int) -> None:
        font = self.font()
        font.setPointSize(size)
        self.setFont(font)

    @deprecated(reason="This method is deprecated, use get_font_metrics instead.")
    def font_metrics(self) -> gui.FontMetrics:
        return self.get_font_metrics()

    def get_font_metrics(self) -> gui.FontMetrics:
        return gui.FontMetrics(self.fontMetrics())

    def get_font_info(self) -> gui.FontInfo:
        return gui.FontInfo(self.fontInfo())

    def set_margin(self, margin: int) -> None:
        self.setContentsMargins(margin, margin, margin, margin)

    def raise_dock(self) -> bool:
        w = self.find_parent(QtWidgets.QDockWidget)
        if w is None:
            return False
        w.setVisible(True)
        w.raise_()
        return True

    def set_mask(
        self,
        area: datatypes.RectType | QtGui.QRegion | None,
        typ: gui.region.RegionTypeStr = "rectangle",
    ):
        match area:
            case None:
                self.clearMask()
                return
            case tuple():
                area = gui.Region(*area, gui.region.REGION_TYPE[typ])
            case QtCore.QRect():
                area = gui.Region(area, gui.region.REGION_TYPE[typ])
        self.setMask(area)

    def set_window_file_path(self, path: datatypes.PathType):
        self.setWindowFilePath(os.fspath(path))

    def get_window_file_path(self) -> pathlib.Path | None:
        path = self.windowFilePath()
        return pathlib.Path(path) if path else None

    def get_image(self) -> QtGui.QPixmap:
        image = self.grab()
        with gui.Painter(image) as painter:
            painter.set_composition_mode("source_atop")
            for gl_widget in self.find_children(QtWidgets.QOpenGLWidget):
                d = gl_widget.mapToGlobal(core.Point()) - self.mapToGlobal(core.Point())
                painter.drawImage(d, gl_widget.grabFramebuffer())
        return image

    def get_screen(self) -> gui.Screen | None:
        window = self.window().windowHandle()
        return None if window is None else gui.Screen(window.screen())

    def delete_children(self):
        """Delete all children of the specified QObject."""
        if hasattr(self, "clear"):
            return self.clear()
        layout = self.layout()
        while layout.count():
            item = layout.takeAt(0)
            if widget := item.widget():
                widget.deleteLater()
            else:
                self.delete_children(item.layout())

    def get_cursor(self) -> gui.Cursor:
        return gui.Cursor(self.cursor())

box: QtWidgets.QLayout class-attribute

_(x: None, y: int | None)

Source code in prettyqt\widgets\widget.py

@set_max_size.register  # these can be merged when min py version is 3.11
def _(self, x: None, y: int | None):
    self.set_max_size((x, y))

__repr__() -> str

Source code in prettyqt\widgets\widget.py

def __repr__(self) -> str:
    return get_repr(self)

center(screen: int = 0) -> None

Source code in prettyqt\widgets\widget.py

def center(self, screen: int = 0) -> None:
    qr = self.frameGeometry()
    cp = gui.GuiApplication.screens()[screen].geometry().center()
    qr.moveCenter(cp)
    self.move(qr.topLeft())

current_font() -> Iterator[gui.Font]

Source code in prettyqt\widgets\widget.py

@deprecated(reason="This context manager is deprecated, use edit_font instead.")
@contextlib.contextmanager
def current_font(self) -> Iterator[gui.Font]:
    with self.edit_font() as font:
        yield font

delete_children()

Delete all children of the specified QObject.

Source code in prettyqt\widgets\widget.py

def delete_children(self):
    """Delete all children of the specified QObject."""
    if hasattr(self, "clear"):
        return self.clear()
    layout = self.layout()
    while layout.count():
        item = layout.takeAt(0)
        if widget := item.widget():
            widget.deleteLater()
        else:
            self.delete_children(item.layout())

edit_font() -> Iterator[gui.Font]

Source code in prettyqt\widgets\widget.py

@contextlib.contextmanager
def edit_font(self) -> Iterator[gui.Font]:
    font = gui.Font(self.font())
    yield font
    self.setFont(font)

edit_palette() -> Iterator[gui.Palette]

Source code in prettyqt\widgets\widget.py

@contextlib.contextmanager
def edit_palette(self) -> Iterator[gui.Palette]:
    palette = gui.Palette(self.palette())
    yield palette
    self.setPalette(palette)

edit_stylesheet() -> Iterator[qstylizer.style.StyleSheet]

Source code in prettyqt\widgets\widget.py

@contextlib.contextmanager
def edit_stylesheet(self) -> Iterator[qstylizer.style.StyleSheet]:
    ss = self.get_stylesheet()
    yield ss
    self.set_stylesheet(ss)

font_metrics() -> gui.FontMetrics

Source code in prettyqt\widgets\widget.py

@deprecated(reason="This method is deprecated, use get_font_metrics instead.")
def font_metrics(self) -> gui.FontMetrics:
    return self.get_font_metrics()

get_background_role() -> gui.palette.RoleStr

Source code in prettyqt\widgets\widget.py

def get_background_role(self) -> gui.palette.RoleStr:
    return gui.palette.ROLE.inverse[self.backgroundRole()]

get_context_menu_policy() -> constants.ContextPolicyStr

Return current contextmenu policy.

Returns:

Type	Description
constants.ContextPolicyStr	contextmenu policy

Source code in prettyqt\widgets\widget.py

def get_context_menu_policy(self) -> constants.ContextPolicyStr:
    """Return current contextmenu policy.

    Returns:
        contextmenu policy
    """
    return constants.CONTEXT_POLICY.inverse[self.contextMenuPolicy()]

get_contextmenu_policy() -> constants.ContextPolicyStr

Return current contextmenu policy.

Returns:

Type	Description
constants.ContextPolicyStr	contextmenu policy

Source code in prettyqt\widgets\widget.py

@deprecated(reason="This method is deprecated, use get_context_menu_policy instead.")
def get_contextmenu_policy(self) -> constants.ContextPolicyStr:
    """Return current contextmenu policy.

    Returns:
        contextmenu policy
    """
    return self.get_context_menu_policy()

get_cursor() -> gui.Cursor

Source code in prettyqt\widgets\widget.py

def get_cursor(self) -> gui.Cursor:
    return gui.Cursor(self.cursor())

get_focus_policy() -> constants.FocusPolicyStr

Return waay the widget accepts keyboard focus.

Returns:

Name	Type	Description
str	constants.FocusPolicyStr	Focus policy

Source code in prettyqt\widgets\widget.py

def get_focus_policy(self) -> constants.FocusPolicyStr:
    """Return waay the widget accepts keyboard focus.

    Returns:
        str: Focus policy
    """
    return constants.FOCUS_POLICY.inverse[self.focusPolicy()]

get_font() -> gui.Font

Source code in prettyqt\widgets\widget.py

def get_font(self) -> gui.Font:
    return gui.Font(self.font())

get_font_info() -> gui.FontInfo

Source code in prettyqt\widgets\widget.py

def get_font_info(self) -> gui.FontInfo:
    return gui.FontInfo(self.fontInfo())

get_font_metrics() -> gui.FontMetrics

Source code in prettyqt\widgets\widget.py

def get_font_metrics(self) -> gui.FontMetrics:
    return gui.FontMetrics(self.fontMetrics())

get_foreground_role() -> gui.palette.RoleStr

Source code in prettyqt\widgets\widget.py

def get_foreground_role(self) -> gui.palette.RoleStr:
    return gui.palette.ROLE.inverse[self.foregroundRole()]

get_icon() -> gui.Icon | None

Source code in prettyqt\widgets\widget.py

def get_icon(self) -> gui.Icon | None:
    icon = self.windowIcon()
    return None if icon.isNull() else gui.Icon(icon)

get_image() -> QtGui.QPixmap

Source code in prettyqt\widgets\widget.py

def get_image(self) -> QtGui.QPixmap:
    image = self.grab()
    with gui.Painter(image) as painter:
        painter.set_composition_mode("source_atop")
        for gl_widget in self.find_children(QtWidgets.QOpenGLWidget):
            d = gl_widget.mapToGlobal(core.Point()) - self.mapToGlobal(core.Point())
            painter.drawImage(d, gl_widget.grabFramebuffer())
    return image

get_modality() -> constants.ModalityStr

Get the current modality modes as a string.

Returns:

Type	Description
constants.ModalityStr	modality mode

Source code in prettyqt\widgets\widget.py

def get_modality(self) -> constants.ModalityStr:
    """Get the current modality modes as a string.

    Returns:
        modality mode
    """
    return constants.MODALITY.inverse[self.windowModality()]

get_palette() -> gui.Palette

Source code in prettyqt\widgets\widget.py

def get_palette(self) -> gui.Palette:
    return gui.Palette(self.palette())

get_screen() -> gui.Screen | None

Source code in prettyqt\widgets\widget.py

def get_screen(self) -> gui.Screen | None:
    window = self.window().windowHandle()
    return None if window is None else gui.Screen(window.screen())

get_size_policy() -> widgets.SizePolicy

Source code in prettyqt\widgets\widget.py

def get_size_policy(self) -> widgets.SizePolicy:
    qpol = self.sizePolicy()
    if isinstance(qpol, widgets.SizePolicy):
        return qpol
    return widgets.SizePolicy.clone(qpol)

get_stylesheet() -> qstylizer.style.StyleSheet

Source code in prettyqt\widgets\widget.py

def get_stylesheet(self) -> qstylizer.style.StyleSheet:
    try:
        return qstylizer.parser.parse(self.styleSheet())
    except ValueError:
        return qstylizer.style.StyleSheet()

get_title() -> str

Source code in prettyqt\widgets\widget.py

def get_title(self) -> str:
    return self.windowTitle()

get_window_file_path() -> pathlib.Path | None

Source code in prettyqt\widgets\widget.py

def get_window_file_path(self) -> pathlib.Path | None:
    path = self.windowFilePath()
    return pathlib.Path(path) if path else None

get_window_state() -> constants.WindowStateStr

Return current window state.

Returns:

Type	Description
constants.WindowStateStr	window state

Source code in prettyqt\widgets\widget.py

def get_window_state(self) -> constants.WindowStateStr:
    """Return current window state.

    Returns:
        window state
    """
    return constants.WINDOW_STATES.inverse[self.windowState()]

grab_keyboard_events() -> Iterator[None]

Source code in prettyqt\widgets\widget.py

@contextlib.contextmanager
def grab_keyboard_events(self) -> Iterator[None]:
    self.grabKeyboard()
    yield None
    self.releaseKeyboard()

grab_mouse_events(cursor_shape: constants.CursorShapeStr | None = None) -> Iterator[None]

Source code in prettyqt\widgets\widget.py

@contextlib.contextmanager
def grab_mouse_events(
    self, cursor_shape: constants.CursorShapeStr | None = None
) -> Iterator[None]:
    if cursor_shape is not None:
        self.grabMouse(constants.CURSOR_SHAPE[cursor_shape])
    else:
        self.grabMouse()
    yield None
    self.releaseMouse()

insertAction(position_or_action: int | QtWidgets.QAction, action: QtWidgets.QAction)

Extend insertAction to also allow int index.

Source code in prettyqt\widgets\widget.py

def insertAction(
    self, position_or_action: int | QtWidgets.QAction, action: QtWidgets.QAction
):
    """Extend insertAction to also allow int index."""
    if isinstance(position_or_action, int):
        position_or_action = self.actions()[position_or_action]
    super().insertAction(position_or_action, action)

raise_dock() -> bool

Source code in prettyqt\widgets\widget.py

def raise_dock(self) -> bool:
    w = self.find_parent(QtWidgets.QDockWidget)
    if w is None:
        return False
    w.setVisible(True)
    w.raise_()
    return True

raise_to_top()

Source code in prettyqt\widgets\widget.py

def raise_to_top(self):
    if sys.platform.startswith("win"):
        import win32con
        from win32gui import SetWindowPos

        # set to always-on-top and disable it again. that way windows stays in front
        flag = win32con.SWP_NOMOVE | win32con.SWP_NOSIZE | win32con.SWP_SHOWWINDOW
        win_id = self.winId()
        SetWindowPos(win_id, win32con.HWND_TOPMOST, 0, 0, 0, 0, flag)
        SetWindowPos(win_id, win32con.HWND_NOTOPMOST, 0, 0, 0, 0, flag)
    # state = (self.windowState() & ~Qt.WindowMinimized) | Qt.WindowActive
    # self.setWindowState(state)
    self.raise_()
    self.show()
    self.activateWindow()

resize(*size) -> None

Source code in prettyqt\widgets\widget.py

def resize(self, *size) -> None:
    if isinstance(size[0], tuple):
        super().resize(*size[0])
    else:
        super().resize(*size)

set_attribute(attribute: constants.WidgetAttributeStr, state: bool = True) -> None

Source code in prettyqt\widgets\widget.py

def set_attribute(
    self, attribute: constants.WidgetAttributeStr, state: bool = True
) -> None:
    if attribute not in constants.WIDGET_ATTRIBUTE:
        raise InvalidParamError(attribute, constants.WIDGET_ATTRIBUTE)
    self.setAttribute(constants.WIDGET_ATTRIBUTE[attribute], state)

set_attributes(**kwargs: bool) -> None

Source code in prettyqt\widgets\widget.py

def set_attributes(self, **kwargs: bool) -> None:
    for attr, state in kwargs.items():
        if attr not in constants.WIDGET_ATTRIBUTE:
            raise InvalidParamError(attr, constants.WIDGET_ATTRIBUTE)
        self.setAttribute(constants.WIDGET_ATTRIBUTE[attr], state)  # type: ignore

set_background_color(color: datatypes.ColorType) -> None

Source code in prettyqt\widgets\widget.py

def set_background_color(self, color: datatypes.ColorType) -> None:
    col_str = "" if color is None else colors.get_color(color).name()
    with self.edit_stylesheet() as ss:
        ss.backgroundColor.setValue(col_str)

set_background_role(role: gui.palette.RoleStr)

Source code in prettyqt\widgets\widget.py

def set_background_role(self, role: gui.palette.RoleStr):
    if role not in gui.palette.ROLE:
        raise InvalidParamError(role, gui.palette.ROLE)
    self.setBackgroundRole(gui.palette.ROLE[role])

set_context_menu_policy(policy: constants.ContextPolicyStr) -> None

Set contextmenu policy for given item view.

Parameters:

Name	Type	Description	Default
policy	constants.ContextPolicyStr	contextmenu policy to use	required

Raises:

Type	Description
InvalidParamError	policy does not exist

Source code in prettyqt\widgets\widget.py

def set_context_menu_policy(self, policy: constants.ContextPolicyStr) -> None:
    """Set contextmenu policy for given item view.

    Args:
        policy: contextmenu policy to use

    Raises:
        InvalidParamError: policy does not exist
    """
    if policy not in constants.CONTEXT_POLICY:
        raise InvalidParamError(policy, constants.CONTEXT_POLICY)
    self.setContextMenuPolicy(constants.CONTEXT_POLICY[policy])

set_contextmenu_policy(policy: constants.ContextPolicyStr) -> None

Source code in prettyqt\widgets\widget.py

@deprecated(reason="This method is deprecated, use set_context_menu_policy instead.")
def set_contextmenu_policy(self, policy: constants.ContextPolicyStr) -> None:
    return self.set_context_menu_policy(policy)

set_cursor(cursor: constants.CursorShapeStr | QtGui.QCursor) -> None

Source code in prettyqt\widgets\widget.py

def set_cursor(self, cursor: constants.CursorShapeStr | QtGui.QCursor) -> None:
    if isinstance(cursor, QtGui.QCursor):
        curs = cursor
    elif cursor in constants.CURSOR_SHAPE:
        curs = gui.Cursor(constants.CURSOR_SHAPE[cursor])
    else:
        raise InvalidParamError(cursor, constants.CURSOR_SHAPE)
    self.setCursor(curs)

set_custom_menu(method: Callable) -> None

Source code in prettyqt\widgets\widget.py

def set_custom_menu(self, method: Callable) -> None:
    self.set_context_menu_policy("custom")
    self.customContextMenuRequested.connect(method)

set_disabled() -> None

Source code in prettyqt\widgets\widget.py

def set_disabled(self) -> None:
    self.setEnabled(False)

set_enabled(enabled: bool = True) -> None

Source code in prettyqt\widgets\widget.py

def set_enabled(self, enabled: bool = True) -> None:
    self.setEnabled(enabled)

set_flags(minimize: bool | None = None, maximize: bool | None = None, close: bool | None = None, stay_on_top: bool | None = None, frameless: bool | None = None, window: bool | None = None, dialog: bool | None = None, tooltip: bool | None = None, tool: bool | None = None, customize: bool | None = None, window_title: bool | None = None) -> None

Source code in prettyqt\widgets\widget.py

def set_flags(
    self,
    minimize: bool | None = None,
    maximize: bool | None = None,
    close: bool | None = None,
    stay_on_top: bool | None = None,
    frameless: bool | None = None,
    window: bool | None = None,
    dialog: bool | None = None,
    tooltip: bool | None = None,
    tool: bool | None = None,
    customize: bool | None = None,
    window_title: bool | None = None,
) -> None:
    flags = {
        minimize: QtCore.Qt.WindowType.WindowMinimizeButtonHint,
        maximize: QtCore.Qt.WindowType.WindowMaximizeButtonHint,
        close: QtCore.Qt.WindowType.WindowCloseButtonHint,
        stay_on_top: QtCore.Qt.WindowType.WindowStaysOnTopHint,
        frameless: QtCore.Qt.WindowType.FramelessWindowHint,
        window: QtCore.Qt.WindowType.Window,
        dialog: QtCore.Qt.WindowType.Dialog,
        tooltip: QtCore.Qt.WindowType.ToolTip,
        tool: QtCore.Qt.WindowType.Tool,
        customize: QtCore.Qt.WindowType.CustomizeWindowHint,
        window_title: QtCore.Qt.WindowType.WindowTitleHint,
    }
    for k, v in flags.items():
        if k is not None:
            self.setWindowFlag(v, k)

set_focus_policy(policy: constants.FocusPolicyStr) -> None

Set the way the widget accepts keyboard focus.

Parameters:

Name	Type	Description	Default
policy	str	Focus policy	required

Raises:

Type	Description
InvalidParamError	Description

Source code in prettyqt\widgets\widget.py

def set_focus_policy(self, policy: constants.FocusPolicyStr) -> None:
    """Set the way the widget accepts keyboard focus.

    Args:
        policy (str): Focus policy

    Raises:
        InvalidParamError: Description
    """
    if policy not in constants.FOCUS_POLICY:
        raise InvalidParamError(policy, constants.FOCUS_POLICY)
    self.setFocusPolicy(constants.FOCUS_POLICY[policy])

set_font(font_name: str | None = None, font_size: int | None = None, weight: int | None = None, italic: bool = False) -> gui.Font

Source code in prettyqt\widgets\widget.py

def set_font(
    self,
    font_name: str | None = None,
    font_size: int | None = None,
    weight: int | None = None,
    italic: bool = False,
) -> gui.Font:
    if font_size is None:
        font_size = -1
    if weight is None:
        weight = -1
    if font_name is None:
        font_name = self.font().family()
    font = gui.Font(font_name, font_size, weight, italic)
    self.setFont(font)
    return font

set_font_size(size: int) -> None

Source code in prettyqt\widgets\widget.py

def set_font_size(self, size: int) -> None:
    font = self.font()
    font.setPointSize(size)
    self.setFont(font)

set_foreground_role(role: gui.palette.RoleStr)

Source code in prettyqt\widgets\widget.py

def set_foreground_role(self, role: gui.palette.RoleStr):
    if role not in gui.palette.ROLE:
        raise InvalidParamError(role, gui.palette.ROLE)
    self.setForegroundRole(gui.palette.ROLE[role])

set_icon(icon: datatypes.IconType) -> None

Set the window icon.

Parameters:

Name	Type	Description	Default
icon	datatypes.IconType	icon to use	required

Source code in prettyqt\widgets\widget.py

def set_icon(self, icon: datatypes.IconType) -> None:
    """Set the window icon.

    Args:
        icon: icon to use
    """
    icon = iconprovider.get_icon(icon, color=colors.WINDOW_ICON_COLOR)
    self.setWindowIcon(icon)

set_layout(layout: LayoutStr | QtWidgets.QLayout | None, margin: int | None = None, spacing: int | None = None)

Source code in prettyqt\widgets\widget.py

def set_layout(
    self,
    layout: LayoutStr | QtWidgets.QLayout | None,
    margin: int | None = None,
    spacing: int | None = None,
):
    if layout is None:
        return
    match layout:
        case "horizontal" | "vertical":
            self.box = widgets.BoxLayout(layout)
        case "grid":
            self.box = widgets.GridLayout()
        case "form":
            self.box = widgets.FormLayout()
        case "stacked":
            self.box = widgets.StackedLayout()
        case "flow":
            from prettyqt import custom_widgets

            self.box = custom_widgets.FlowLayout()
        case QtWidgets.QLayout():
            self.box = layout
        case _:
            raise ValueError("Invalid Layout")
    self.setLayout(self.box)
    if margin is not None:
        self.box.set_margin(margin)
    if spacing is not None:
        self.box.setSpacing(spacing)

set_margin(margin: int) -> None

Source code in prettyqt\widgets\widget.py

def set_margin(self, margin: int) -> None:
    self.setContentsMargins(margin, margin, margin, margin)

set_mask(area: datatypes.RectType | QtGui.QRegion | None, typ: gui.region.RegionTypeStr = 'rectangle')

Source code in prettyqt\widgets\widget.py

def set_mask(
    self,
    area: datatypes.RectType | QtGui.QRegion | None,
    typ: gui.region.RegionTypeStr = "rectangle",
):
    match area:
        case None:
            self.clearMask()
            return
        case tuple():
            area = gui.Region(*area, gui.region.REGION_TYPE[typ])
        case QtCore.QRect():
            area = gui.Region(area, gui.region.REGION_TYPE[typ])
    self.setMask(area)

set_max_height(height: int | None) -> None

Source code in prettyqt\widgets\widget.py

def set_max_height(self, height: int | None) -> None:
    if height is None:
        height = QWIDGETSIZE_MAX
    self.setMaximumHeight(height)

set_max_size(size: QtCore.QSize | tuple[int | None, int | None]) -> None

Source code in prettyqt\widgets\widget.py

@functools.singledispatchmethod
def set_max_size(self, size: QtCore.QSize | tuple[int | None, int | None]) -> None:
    if isinstance(size, tuple):
        x = QWIDGETSIZE_MAX if size[0] is None else size[0]
        y = QWIDGETSIZE_MAX if size[1] is None else size[1]
        self.setMaximumSize(x, y)
    else:
        self.setMaximumSize(size)

set_max_width(width: int | None) -> None

Source code in prettyqt\widgets\widget.py

def set_max_width(self, width: int | None) -> None:
    if width is None:
        width = QWIDGETSIZE_MAX
    self.setMaximumWidth(width)

set_min_height(height: int | None) -> None

Source code in prettyqt\widgets\widget.py

def set_min_height(self, height: int | None) -> None:
    if height is None:
        height = 0
    self.setMinimumHeight(height)

set_min_size(size: QtCore.QSize | tuple[int | None, int | None]) -> None

Source code in prettyqt\widgets\widget.py

@functools.singledispatchmethod
def set_min_size(self, size: QtCore.QSize | tuple[int | None, int | None]) -> None:
    if isinstance(size, tuple):
        x = 0 if size[0] is None else size[0]
        y = 0 if size[1] is None else size[1]
        self.setMinimumSize(x, y)
    else:
        self.setMinimumSize(size)

set_min_width(width: int | None) -> None

Source code in prettyqt\widgets\widget.py

def set_min_width(self, width: int | None) -> None:
    if width is None:
        width = 0
    self.setMinimumWidth(width)

set_modality(modality: constants.ModalityStr) -> None

Set modality for the dialog.

Parameters:

Name	Type	Description	Default
modality	constants.ModalityStr	modality for the main window	required

Raises:

Type	Description
InvalidParamError	modality type does not exist

Source code in prettyqt\widgets\widget.py

def set_modality(self, modality: constants.ModalityStr) -> None:
    """Set modality for the dialog.

    Args:
        modality: modality for the main window

    Raises:
        InvalidParamError: modality type does not exist
    """
    if modality not in constants.MODALITY:
        raise InvalidParamError(modality, constants.MODALITY)
    self.setWindowModality(constants.MODALITY[modality])

set_size_policy(horizontal: widgets.sizepolicy.SizePolicyStr | None = None, vertical: widgets.sizepolicy.SizePolicyStr | None = None) -> None

Set the sizes policy.

Parameters:

Name	Type	Description	Default
horizontal	widgets.sizepolicy.SizePolicyStr | None	horizontal size policy	None
vertical	widgets.sizepolicy.SizePolicyStr | None	vertical size policy	None

Source code in prettyqt\widgets\widget.py

def set_size_policy(
    self,
    horizontal: widgets.sizepolicy.SizePolicyStr | None = None,
    vertical: widgets.sizepolicy.SizePolicyStr | None = None,
) -> None:
    """Set the sizes policy.

    Args:
        horizontal: horizontal size policy
        vertical: vertical size policy
    """
    sp = self.get_size_policy()
    if horizontal is not None:
        sp.set_horizontal_policy(horizontal)
    if vertical is not None:
        sp.set_vertical_policy(vertical)
    self.setSizePolicy(sp)

set_stylesheet(ss: None | str | qstylizer.style.StyleSheet | datatypes.PathType)

Source code in prettyqt\widgets\widget.py

def set_stylesheet(
    self, ss: None | str | qstylizer.style.StyleSheet | datatypes.PathType
):
    match ss:
        case None:
            ss = ""
        case os.PathLike():
            ss = pathlib.Path(ss).read_text()
        case qstylizer.style.StyleSheet():
            ss = str(ss)
    self.setStyleSheet(ss)

set_title(title: str) -> None

Source code in prettyqt\widgets\widget.py

def set_title(self, title: str) -> None:
    self.setWindowTitle(title)

set_tooltip(tooltip: str | datatypes.PathType, size: datatypes.SizeType | None = None)

Source code in prettyqt\widgets\widget.py

def set_tooltip(
    self,
    tooltip: str | datatypes.PathType,
    size: datatypes.SizeType | None = None,
):
    if isinstance(tooltip, os.PathLike):
        path = os.fspath(tooltip)
        if size is None:
            tooltip = f"<img src={path!r}>"
        else:
            if isinstance(size, QtCore.QSize):
                size = (size.width(), size.height())
            tooltip = f'<img src={path!r} width="{size[0]}" height="{size[1]}">'
    self.setToolTip(tooltip)

set_window_file_path(path: datatypes.PathType)

Source code in prettyqt\widgets\widget.py

def set_window_file_path(self, path: datatypes.PathType):
    self.setWindowFilePath(os.fspath(path))

set_window_flags(*flags: constants.WindowFlagStr, append: bool = False)

Source code in prettyqt\widgets\widget.py

def set_window_flags(self, *flags: constants.WindowFlagStr, append: bool = False):
    for flag in flags:
        if flag not in constants.WINDOW_FLAGS:
            raise InvalidParamError(flag, constants.WINDOW_FLAGS)
    result = helpers.merge_flags(flags, constants.WINDOW_FLAGS)
    if append:
        result = result | self.windowFlags()
    self.setWindowFlags(result)

set_window_state(policy: constants.WindowStateStr) -> None

Set window state for given item view.

Parameters:

Name	Type	Description	Default
policy	constants.WindowStateStr	window state to use	required

Raises:

Type	Description
InvalidParamError	policy does not exist

Source code in prettyqt\widgets\widget.py

def set_window_state(self, policy: constants.WindowStateStr) -> None:
    """Set window state for given item view.

    Args:
        policy: window state to use

    Raises:
        InvalidParamError: policy does not exist
    """
    if policy not in constants.WINDOW_STATES:
        raise InvalidParamError(policy, constants.WINDOW_STATES)
    self.setWindowState(constants.WINDOW_STATES[policy])

toggle_fullscreen()

Toggle between fullscreen and regular size.

Source code in prettyqt\widgets\widget.py

def toggle_fullscreen(self):
    """Toggle between fullscreen and regular size."""
    if self.isFullScreen():
        self.showNormal()
    else:
        self.showFullScreen()

toggle_maximized()

Toggle between maximized and regular size.

Source code in prettyqt\widgets\widget.py

def toggle_maximized(self):
    """Toggle between maximized and regular size."""
    if self.isMaximized():
        self.showNormal()
    else:
        self.showMaximized()

updates_off() -> Iterator[None]

Source code in prettyqt\widgets\widget.py

@contextlib.contextmanager
def updates_off(self) -> Iterator[None]:
    updates = self.updatesEnabled()
    self.setUpdatesEnabled(False)
    yield None
    self.setUpdatesEnabled(updates)

Wizard

Bases: WizardMixin, QtWidgets.QWizard

Source code in prettyqt\widgets\wizard.py

class Wizard(WizardMixin, QtWidgets.QWizard):
    pass

WizardPage

Bases: WizardPageMixin, QtWidgets.QWizardPage

Source code in prettyqt\widgets\wizardpage.py

class WizardPage(WizardPageMixin, QtWidgets.QWizardPage):
    pass

app(args: list[str] | None = None) -> Application

Source code in prettyqt\widgets\__init__.py

def app(args: list[str] | None = None) -> Application:
    if (instance := Application.instance()) is not None:
        return instance
    Application.disable_window_help_button()
    #  + ["--ignore-gpu-blacklist", "--enable-gpu-rasterization"]
    return Application(sys.argv if args is None else args)